स्थैतिक कोड विश्लेषण में मेरा पसंदीदा हिस्सा कोड में संभावित त्रुटियों के बारे में परिकल्पना को आगे बढ़ा रहा है और फिर उन्हें जांच रहा है।

परिकल्पना उदाहरण:

 strpos      .

लेकिन एक मौका है कि कोड की कई मिलियन लाइनों पर भी इस तरह का निदान "शूट" नहीं होगा, इसलिए आप असफल परिकल्पनाओं पर बहुत समय बिताना नहीं चाहते हैं।

आज मैं दिखाऊंगा कि कैसे बिना कोड लिखे phpgrep यूटिलिटी का उपयोग करके सबसे सरल स्थैतिक विश्लेषण किया जाता है ।

कटौती के तहत:

ओपन सोर्स प्रोजेक्ट्स में बग्स की खोज और विश्लेषण।
Phpgrep द्वारा त्वरित शुरुआत।
सिंटैक्टिक खोज का सिद्धांत।

आवश्यक शर्तें

अब कई महीनों से, मैं NoVerify PHP linter का समर्थन कर रहा हूं ( NoVerify लेख में इसके बारे में पढ़ें : Linter for PHP से VKontakte Team )।

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

पहले, मैं सक्रिय रूप से गो-आलोचक विकसित कर रहा था और स्थिति समान थी, एकमात्र अंतर यह था कि स्रोतों का विश्लेषण गो में किया गया था, न कि PHP में। जब मुझे गोगरेप की उपयोगिता के बारे में पता चला, तो मेरी दुनिया पलट गई। जैसा कि नाम से ही स्पष्ट है, इस उपयोगिता में grep के साथ कुछ सामान्य है, केवल खोज नियमित अभिव्यक्तियों द्वारा नहीं, बल्कि सिंटैक्स पैटर्नों द्वारा की जाती है (मैं बाद में इसका मतलब क्या होगा) बताऊंगा।

मैं चालाक grep के बिना नहीं रहना चाहता था, इसलिए एक शाम मैंने नीचे बैठकर phpgrep लिखने का phpgrep ।

विश्लेषण किया गया मामला

मज़ेदार होने के लिए, हम तुरंत आवेदन में खुद को विसर्जित कर देते हैं। हम GitHub पर उपलब्ध काफी प्रसिद्ध और बड़ी PHP परियोजनाओं के एक छोटे सेट का विश्लेषण करेंगे।

हमारी किट में निम्नलिखित परियोजनाएं शामिल थीं:

वर्डप्रेस	विकिया	Drupal
yii2	CodeIgniter	संगीतकार
फाल्कन	जूमला!	Laravel
Moodle	खुद की कोर	Phabricator
PHPUnit	सिम्फोनी	woocommerce

उन लोगों के लिए जो हम साजिश रच रहे हैं, यह एक बहुत ही स्वादिष्ट सेट है।

तो चलिए!

अभिव्यक्ति के रूप में असाइनमेंट का उपयोग करना

यदि असाइनमेंट का उपयोग अभिव्यक्ति के रूप में किया जाता है, तो इसके अतिरिक्त:

संदर्भ एक तार्किक ऑपरेशन (तार्किक स्थिति) और के परिणाम की उम्मीद करता है
अभिव्यक्ति के दाईं ओर कोई दुष्प्रभाव नहीं है और स्थिर है,

यह कोड में सबसे अधिक संभावना है।

शुरू करने के लिए, चलो "तार्किक संदर्भ" के लिए निम्नलिखित निर्माणों को लेते हैं:

अभिव्यक्ति के अंदर " if ($cond) "।
टर्नेरी ऑपरेटर की स्थिति है: " $cond ? $x : $y "।
छोरों के लिए निरंतरता की स्थिति " while ($cond) " और "के for ($init; $cond; $post) "।

असाइनमेंट के दाईं ओर, हम स्थिरांक या शाब्दिक की अपेक्षा करते हैं।

हमें ऐसे प्रतिबंधों की आवश्यकता क्यों है?

झूठी सकारात्मकता की संख्या को कम करने के लिए दोनों प्रतिबंधों की आवश्यकता है।

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

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

चलो शुरू (1) के साथ:

 #      # |      (  ) # | | # | | phpgrep . 'if ($_ = []) $_' # 1 # | # | #    #  3    . phpgrep . 'if ($_ = ${"const"}) $_' # 2 phpgrep . 'if ($_ = ${"str"}) $_' # 3 phpgrep . 'if ($_ = ${"num"}) $_' # 4

यहां हम 4 पैटर्न देखते हैं, जिसके बीच एकमात्र अंतर निर्दिष्ट अभिव्यक्ति (RHS) है। पहले एक के साथ शुरू करते हैं।

टेम्पलेट " if ($_ = []) $_ " एक को पकड़ता है, जिसमें किसी भी अभिव्यक्ति के लिए एक खाली सरणी है। $_ किसी भी अभिव्यक्ति या कथन से मेल खाता है।

     (RHS) | if ($_ = []) $_ | | |   if',   ,  {}    LHS

निम्नलिखित उदाहरण अधिक जटिल कास्ट , स्ट्र, और संख्या समूहों का उपयोग करते हैं। $_ विपरीत $_ वे संगत संचालन पर प्रतिबंध का वर्णन करते हैं।

const एक नामित स्थिरांक या वर्ग स्थिरांक है।
str किसी भी प्रकार का एक स्ट्रिंग शाब्दिक है।
num किसी भी प्रकार का एक संख्यात्मक शाब्दिक है।

ये पैटर्न मामले पर कई संचालन प्राप्त करने के लिए पर्याप्त हैं।

⎆ मनोदशा / ब्लॉक / rss_client / viewfeed.php # L37 :

 if ($courseid = SITEID) { $courseid = 0; }

मूड में दूसरी ट्रिगर एडीओडीबी निर्भरता थी। अपस्ट्रीम लाइब्रेरी में, समस्या अभी भी मौजूद है।

⎆ ADOdb / ड्राइवर / adodb-odbtp.inc.php # L741 :

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

एक और दिलचस्प जगह जहां हम केवल "सही" रिकॉर्ड के लिए कार्रवाई करना चाहते हैं, लेकिन इसके बजाय, हमेशा उन्हें निष्पादित करें और इसके अलावा, किसी भी रिकॉर्ड को सही मानें!

⎆ मनोदशा / प्रश्न / प्रारूप / ब्लैकबोर्ड_सिक्स / स्वरूपक.प्र। # L598 :

 // For BB Fill in the Blank, only interested in correct answers. if ($response->feedback = 'correct') { // ... }

इस जाँच के लिए टेम्प्लेट की विस्तारित सूची

  phpgrep।  'for ($ _? $ _ = []; $ _) $ _'
 phpgrep।  'for ($ _; $ _ = $ {"const"}; $ _) $ _'
 phpgrep।  'for ($ _; $ _ = $ {"संख्या"}; $ _) $ _'
 phpgrep।  'for ($ _; $ _ = $ {"str"}; $ _) $ _'
 phpgrep।  'जबकि ($ _ = []) $ _'
 phpgrep।  'जबकि ($ _ = $ {"कास्ट"}) $ _'
 phpgrep।  'जबकि ($ _ = $ {"संख्या"}) $ _'
 phpgrep।  'जबकि ($ _ = $ {"str"}) $ _'
 phpgrep।  'अगर ($ _ = []) $ _'
 phpgrep।  'if ($ _ = $ {"const"}) $ _'
 phpgrep।  'if ($ _ = $ {"str"}) $ _'
 phpgrep।  'अगर ($ _ = $ {"संख्या"}) $ _'
 phpgrep।  '$ _ = []?  $ _: $ _ '
 phpgrep।  '$ _ = $ {"कास्ट"}?  $ _: $ _ '
 phpgrep।  '$ _ = $ {"str"}?  $ _: $ _ '
 phpgrep।  '$ _ = $ {"संख्या"}?  $ _: $ _ '
 phpgrep।  '($ _ = []) और& $ _'
 phpgrep।  '($ _ = $ {"कास्ट"}) और& $ _'
 phpgrep।  '($ _ = $ {"str"}) और& $ _'
 phpgrep।  '($ _ = $ {"संख्या"}) और& $ _'
 phpgrep।  '$ _ && $ _ = []'
 phpgrep।  '$ _ && $ _ = $ {"कास्ट"}'
 phpgrep।  '$ _ && $ _ = $ {"str"}'
 phpgrep।  '$ _ && $ _ = $ {"संख्या"}'
 phpgrep।  '($ _ = []) ||  $ _ '
 phpgrep।  '($ _ = $ {"कास्ट"}) ||  $ _ '
 phpgrep।  '($ _ = $ {"str"}) ||  $ _ '
 phpgrep।  '($ _ = $ {"संख्या"}) ||  $ _ '
 phpgrep।  '$ _ ||  $ _ = [] '
 phpgrep।  '$ _ ||  $ _ = $ {"कास्ट"} '
 phpgrep।  '$ _ ||  $ _ = $ {"str"} '
 phpgrep।  '$ _ ||  $ _ = $ {"संख्या"} '

आइए दोहराएं कि हमने क्या सीखा:

टेम्प्लेट उनके द्वारा खोजे गए php कोड की तरह दिखते हैं।
$_ किसी भी चीज के लिए खड़ा है। आप तुलना कर सकते हैं . नियमित अभिव्यक्तियों में।
${"<class>"} एक AST तत्व प्रकार प्रतिबंध के साथ $_ तरह काम करता है।

यह भी जोर देने योग्य है कि चर को छोड़कर सब कुछ शाब्दिक रूप से मैप किया गया है। इसका मतलब है कि पैटर्न " array(1, 2 + 3) " सिंटैक्टिक संरचना में समान कोड से ही संतुष्ट हो जाएगा (रिक्त स्थान प्रभावित नहीं करते हैं)। दूसरी ओर, पैटर्न " array($_, $_) " किसी भी दो-तत्व सरणी शाब्दिक को संतुष्ट करता है।

अपने आप से एक अभिव्यक्ति की तुलना करना

अपने आप से कुछ तुलना करने की आवश्यकता बहुत कम है। यह एक NaN जाँच हो सकती है, लेकिन कम से कम आधे समय में यह कॉपी / पेस्ट त्रुटि है।

⎆ विकिया / ऐप / एक्सटेंशन / सेमेटिकड्रिलडाउन / शामिल / SD_FilterValue.php # एलआईसी :

 if ( $fv1->month == $fv1->month ) return 0;

दाईं ओर " $fv2->month " होना चाहिए।

एक टेम्पलेट में डुप्लिकेट भागों को व्यक्त करने के लिए, हम " _ " के अलावा अन्य नामों के साथ चर का उपयोग करते हैं। एक पैटर्न में पुनरावृत्ति तंत्र नियमित अभिव्यक्तियों में बैकलिंक्स के समान है।

पैटर्न " $x == $x " वही होगा जो ऊपर दिए गए उदाहरण से मिलता है। " x " के बजाय, किसी भी नाम का उपयोग किया जा सकता है। यह केवल महत्वपूर्ण है कि नाम समान हैं। कैप्चर वैरिएबल जिनके नाम अलग हैं, उन्हें कैप्चर करते समय समान सामग्री की आवश्यकता नहीं है।

निम्न उदाहरण " $x <= $x " का उपयोग करते हुए पाया गया था।

⎆ Drupal / core / मॉड्यूल / विचार / परीक्षण / src / Unit / ViewsDataTest.php # L166 :

 $prev = $base_tables[$base_tables_keys[$i - 1]]; $current = $base_tables[$base_tables_keys[$i]]; $this->assertTrue( $prev['weight'] <= $current['weight'] && $prev['title'] <= $prev['title'], // <--------------  'The tables are sorted as expected.');

डुप्लिकेट सबटेक्शन्स

अब जब हम बार-बार सबटेक्शंस की संभावनाओं के बारे में जानते हैं, तो हम कई दिलचस्प पैटर्न बना सकते हैं।

मेरा पसंदीदा में से एक " $_ ? $x : $x " है।
यह सच्ची / झूठी शाखाओं के साथ एक टर्नरी ऑपरेटर है।

S जूमला-सेमी / लाइब्रेरी / src / उपयोगकर्ता / उपयोगकर्ता हेल्पर। एफपी # एल ५२२ :

 return ($show_encrypt) ? '{SHA256}' . $encrypted : '{SHA256}' . $encrypted;

दोनों शाखाओं को डुप्लिकेट किया गया है, जो कोड में एक संभावित समस्या का सुझाव देता है। यदि हम आस-पास के कोड को देखते हैं, तो हम समझ सकते हैं कि इसके बजाय क्या होना चाहिए था। पठनीयता की खातिर, मैंने कोड का हिस्सा काट दिया और चर का नाम घटाकर $enc $encrypted कर दिया।

 case 'crypt-blowfish': return ($show_encrypt ? '{crypt}' : '') . crypt($plaintext, $salt); case 'md5-base64': return ($show_encrypt) ? '{MD5}' . $enc : $enc; case 'ssha': return ($show_encrypt) ? '{SSHA}' . $enc : $enc; case 'smd5': return ($show_encrypt) ? '{SMD5}' . $enc : $enc; case 'sha256': return ($show_encrypt) ? '{SHA256}' . $enc : '{SHA256}' . $enc; default: return ($show_encrypt) ? '{MD5}' . $enc : $enc;

मुझे विश्वास है कि कोड को निम्नलिखित पैच की आवश्यकता होगी:

 - ($show_encrypt) ? '{SHA256}' . $encrypted : '{SHA256}' . $encrypted; + ($show_encrypt) ? '{SHA256}' . $encrypted : $encrypted;

PHP में खतरनाक ऑपरेशन प्राथमिकताएँ

PHP में एक अच्छा एहतियात जहाँ भी गणना के सही क्रम का होना महत्वपूर्ण है, वहाँ कोष्ठक के समूह का उपयोग किया जाता है।

कई प्रोग्रामिंग भाषाओं में, अभिव्यक्ति " x & mask != 0 " का एक सहज अर्थ है। यदि mask थोड़ा वर्णन करता है, तो यह कोड जांचता है कि x यह बिट शून्य के बराबर नहीं है। दुर्भाग्य से, PHP के लिए यह अभिव्यक्ति इस तरह से गणना की जाएगी: " x & (mask != 0) ", जो लगभग हमेशा वह नहीं है जो आपको चाहिए।

वर्डप्रेस, जूमला और मूडल सिंपलीपे का इस्तेमाल करते हैं।

⎆ SimplePie / पुस्तकालय / SimplePie / Locator.php # L254
⎆ SimplePie / पुस्तकालय / SimplePie / Locator.php # L384
⎆ SimplePie / पुस्तकालय / SimplePie / Locator.php # L412
⎆ SimplePie / पुस्तकालय / SimplePie / Sanitize.php # L349
⎆ SimplePie / पुस्तकालय / SimplePie.php # L1634

 $feed->method & SIMPLEPIE_FILE_SOURCE_REMOTE === 0

SIMPLEPIE_FILE_SOURCE_REMOTE को 1 रूप SIMPLEPIE_FILE_SOURCE_REMOTE परिभाषित किया गया है, इसलिए अभिव्यक्ति इसके समकक्ष होगी:

 $feed->method & (1 === 0) // => $feed->method & false

नमूना खोज टेम्पलेट

  phpgrep।  '$ x और $ मास्क == $ y'
 phpgrep।  '$ x और $ मास्क === $ y'
 phpgrep।  '$ x और $ मास्क! == $ y'
 phpgrep।  '$ x & $ मास्क! = $ y'
 phpgrep।  '$ x |  $ मास्क == $ y '
 phpgrep।  '$ x |  $ मास्क === $ y '
 phpgrep।  '$ x |  $ मुखौटा! == $ y '
 phpgrep।  '$ x |  $ मुखौटा! = $ y '

अप्रत्याशित संचालन प्राथमिकताओं के विषय को जारी रखते हुए, आप PHP में टर्नरी ऑपरेटर के बारे में पढ़ सकते हैं। हब्र पर भी लेख इसके लिए समर्पित था: टर्नरी ऑपरेटर के निष्पादन का क्रम ।

क्या phpgrep साथ ऐसी जगहों को ढूंढना संभव है? जवाब है हां !

 phpgrep . '$_ == $_ ? $_ : $_ ? $_ : $_' phpgrep . '$_ != $_ ? $_ : $_ ? $_ : $_'

नियमित अभिव्यक्ति के लाभ के लाभ

⎆ विकिया / ऐप / रखरखाव / विकिया / अपडेटसेंटरालइंटरविक्की.inc # L95 :

 if ( preg_match( '/(wowwiki.com|wikia.com|falloutvault.com)/', $url ) ) { $local = 1; } else { $local = 0; }

जैसा कि कोड के लेखक द्वारा कल्पना की गई है, हम 3 में से एक विकल्प के साथ संयोग के लिए URL की जांच करते हैं। क्षमा करें प्रतीक . परिरक्षित नहीं, जो इस तथ्य की ओर ले जाएगा कि falloutvault.com बजाय हम किसी भी डोमेन पर falloutvaultxcom प्राप्त कर सकते हैं और परीक्षण पास कर सकते हैं।

यह एक PHP विशिष्ट त्रुटि नहीं है। किसी भी आवेदन में जहां नियमित अभिव्यक्तियों के माध्यम से सत्यापन किया जाता है और एक मेटा चरित्र की जाँच की जा रही स्ट्रिंग का हिस्सा है, वहाँ भागने को भूलने का जोखिम है जहां इसकी आवश्यकता होती है और एक भेद्यता प्राप्त होती है।

आप phpgrep चलाकर ऐसी जगहें पा सकते हैं:

 phpgrep . 'preg_match(${"pat:str"}, ${"*"})' 'pat~[^\\]\.(com|ru|net|org)\b'

हम नामित pat सबपैटर्न का परिचय देते हैं, जो किसी भी स्ट्रिंग शाब्दिक को पकड़ता है, और फिर नियमित अभिव्यक्ति से एक फ़िल्टर लागू करता है।

फिल्टर किसी भी टेम्पलेट चर पर लागू किया जा सकता है। नियमित अभिव्यक्तियों के अलावा, संरचनात्मक ऑपरेटर भी हैं = और != । एक पूरी सूची प्रलेखन में पाई जा सकती है।

${"*"} किसी भी तर्क की एक मनमानी संख्या को पकड़ता है, इसलिए हमें preg_match फ़ंक्शन के वैकल्पिक मापदंडों के बारे में चिंता करने की ज़रूरत नहीं है।

सरणी शाब्दिक में डुप्लिकेट कुंजी

यदि आप इस कोड को निष्पादित करते हैं, तो PHP में, आपको कोई चेतावनी नहीं मिलेगी:

 <?php var_dump(['a' => 1, 'a' => 2]); // : array(1) {["a"]=> int(2)}

हम इस तरह के सरणियों को phpgrep का उपयोग करके पा सकते हैं:

 [${"*"}, $k => $_, ${"*"}, $k => $_, ${"*"}]

इस पैटर्न को निम्नानुसार डिक्रिप्ट किया जा सकता है: "एक सरणी शाब्दिक जिसमें एक मनमाना स्थिति में कम से कम दो समान कुंजी हैं।" भाव ${"*"} हमें एक "मनमाना स्थिति" का वर्णन करने में मदद करते हैं, जिससे 0-N तत्वों को पहले, बीच में और हमारे लिए ब्याज की कुंजी के बाद अनुमति मिलती है।

⎆ विकिया / ऐप / एक्सटेंशन / विकिया / विकियामिनीअपलोड / विकियामिनीअपलोड_बॉडी # एफपी # एल २३ :

 $script_a = [ 'wmu_back' => wfMessage( 'wmu_back' )->escaped(), 'wmu_back' => wfMessage( 'wmu_back' )->escaped(), // ... ];

इस मामले में, यह एक सकल गलती नहीं है, लेकिन मुझे ऐसे मामलों के बारे में पता है जहां बड़े (100+ तत्वों) सरणियों में डुप्लिकेटिंग कुंजियों ने कम से कम एक अप्रत्याशित व्यवहार किया जिसमें चाबियों में से एक ने दूसरे के मूल्य को ओवरलैप किया।

यह उदाहरणों के साथ हमारे संक्षिप्त भ्रमण का समापन करता है। यदि आप अधिक चाहते हैं, तो लेख के अंत में वर्णन करता है कि सभी परिणाम कैसे प्राप्त करें।

Phpgrep क्या है?

अधिकांश संपादक और IDE कोड खोजने के लिए नियमित पाठ खोज का उपयोग करते हैं (यदि यह किसी विशेष वर्ण जैसे वर्ग या चर के लिए खोज नहीं है) - दूसरे शब्दों में, grep जैसा कुछ।

आप " $x " दर्ज करें, " $x " ढूंढें। नियमित अभिव्यक्ति आपके लिए उपलब्ध हो सकती है, तो आप वास्तव में नियमित रूप से PHP कोड को पार्स करने का प्रयास कर सकते हैं। कभी-कभी यह भी काम करता है यदि आप कुछ विशिष्ट और सरल की तलाश कर रहे हैं - उदाहरण के लिए, "कुछ प्रत्यय के साथ कोई भी चर।" लेकिन अगर प्रत्यय वाला यह चर किसी अन्य यौगिक अभिव्यक्ति का हिस्सा होना चाहिए, तो कठिनाइयाँ पैदा होती हैं।

phpgrep PHP कोड के लिए सुविधाजनक खोज के लिए एक उपकरण है, जो आपको टेक्स्ट-ओरिएंटेड रेगुलर का उपयोग न करके सिंटेक्स- अवेयर टेम्प्लेट का उपयोग करके खोज करने की अनुमति देता है।

सिंटेक्स-जागरूक का मतलब है कि टेम्पलेट भाषा लक्ष्य भाषा को दर्शाती है, और व्यक्तिगत पात्रों पर काम नहीं करती है, जैसा कि नियमित अभिव्यक्ति करते हैं। कोड को फॉर्मेट करने से पहले हमें भी कोई फर्क नहीं पड़ता है, केवल इसकी संरचना महत्वपूर्ण है।

वैकल्पिक सामग्री: त्वरित शुरुआत

जल्दी शुरू करो

स्थापना

लिनक्स और विंडोज के लिए amd64 के लिए रेडीमेड रिलीज़ बिल्ड हैं , लेकिन यदि आपने गो स्थापित किया है, तो आपके प्लेटफॉर्म के लिए एक नया बाइनरी प्राप्त करने के लिए एक कमांड पर्याप्त है:

 go get -v github.com/quasilyte/phpgrep/cmd/phpgrep

यदि $GOPATH/bin सिस्टम $PATH , तो phpgrep कमांड तुरंत उपलब्ध हो जाएगा। इसे सत्यापित करने के लिए, -help पैरामीटर के साथ कमांड चलाने का प्रयास करें:

 phpgrep -help

यदि कुछ नहीं होता है, तो यह पता लगाएं कि गो ने बाइनरी को कहां स्थापित किया है और इसे $PATH पर्यावरण चर में जोड़ें।

$GOPATH को देखने का एक पुराना और विश्वसनीय तरीका, भले ही वह स्पष्ट रूप से सेट न हो:

 go env GOPATH

के उपयोग

एक परीक्षण बनाएं hello.php फ़ाइल:

 <?php function f(...$xs) {} f(10); f(20); f(30); f($x); f();

phpgrep पर phpgrep चलाएं:

 # phpgrep hello.php 'f(${"x:int"})' 'x!=20' hello.php:3: f(10) hello.php:5: f(30)

हमने फ़ंक्शन f लिए सभी कॉल को एक तर्क के साथ पाया, एक संख्या जिसका मान 20 के बराबर नहीं है।

Phpgrep कैसे काम करता है

PHP को पार्स करने के लिए, github.com/z7zmey/php-parser लाइब्रेरी का उपयोग किया जाता है। यह काफी अच्छा है, लेकिन phpgrep की कुछ सीमाओं का उपयोग किए गए पार्सर की सुविधाओं से किया जाता है। विशेष रूप से कोष्ठक के साथ सामान्य रूप से काम करने की कोशिश करते समय बहुत सारी कठिनाइयां उत्पन्न होती हैं।

phpgrep का सिद्धांत सरल है:

एएसटी इनपुट टेम्प्लेट से बनाया गया है, फिल्टर डिसेबल्ड हैं;
प्रत्येक इनपुट फ़ाइल के लिए, एक पूर्ण एएसटी पेड़ बनाया गया है;
हम प्रत्येक फ़ाइल के एएसटी के चारों ओर जाते हैं, ऐसे उपप्रकार खोजने की कोशिश करते हैं जो पैटर्न से मेल खाते हैं;
प्रत्येक परिणाम के लिए फ़िल्टर की एक सूची लागू की जाती है;
सभी परिणाम जो फ़िल्टर पास कर चुके हैं, स्क्रीन पर मुद्रित होते हैं।

सबसे दिलचस्प यह है कि समानता के लिए दो एएसटी नोड्स वास्तव में कैसे मेल खाते हैं। कभी-कभी तुच्छ: एक-से-एक, और मेटा-नोड्स एक से अधिक तत्वों को पकड़ सकते हैं। मेटा नोड्स के उदाहरण ${"*"} और ${"str"} ।

निष्कर्ष

संरचनात्मक खोज और phpgrep प्रतिस्थापित (SSR) का उल्लेख किए बिना phpgrep बारे में बात करना बेईमानी होगी। वे इसी तरह की समस्याओं को हल करते हैं, और एसएसआर के अपने फायदे हैं, उदाहरण के लिए, आईडीई में एकीकरण, और phpgrep दावा है कि यह एक स्टैंडअलोन कार्यक्रम है, जो कि सीआई के लिए, उदाहरण के लिए, बहुत आसान है।

अन्य बातों के अलावा, phpgrep एक पुस्तकालय भी है जिसका उपयोग आप PHP कोड के मिलान के लिए अपने कार्यक्रमों में कर सकते हैं। यह विशेष रूप से लिंटर और कोड पीढ़ी के लिए उपयोगी है।

मुझे खुशी होगी अगर यह उपकरण आपके लिए उपयोगी है। यदि यह लेख आपको उपरोक्त SSR की दिशा में देखने के लिए प्रेरित करता है, तो यह भी अच्छा है।

अतिरिक्त सामग्री

विश्लेषण के लिए उपयोग किए जाने वाले पैटर्न की पूरी सूची pattern.txt फ़ाइल में पाई जा सकती है। इस फ़ाइल के आगे, आप phpgrep-lint.sh स्क्रिप्ट पा सकते हैं, जो टेम्पलेट की सूची के साथ phpgrep के लॉन्च को सरल करता है।

लेख प्रतिक्रियाओं की पूरी सूची प्रदान नहीं करता है, लेकिन आप सभी नामित रिपॉजिटरी को क्लोन करके और उन पर phpgrep-lint.sh चलाकर प्रयोग को पुन: प्रस्तुत कर सकते हैं।

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

 #  "x != y || x != z": phpgrep . '$x != $a || $x != $b' phpgrep . '$x !== $a || $x != $b' phpgrep . '$x != $a || $x !== $b' phpgrep . '$x !== $a || $x !== $b'

आपको phpgrep की प्रस्तुति में भी रुचि हो सकती है : वाक्य रचना-जागरूक कोड खोज ।

लेख गोफर की छवियों का उपयोग करता है जो कि गोफरकोन के माध्यम से बनाई गई थीं ।

हम स्थैतिक विश्लेषक के बिना PHP कोड में बग की तलाश कर रहे हैं