हार्ड लूप्स बायपासिंग लूप्स

कड़ी कड़ी

एक कड़ी एक चर है जो दूसरे चर के लिए एक पर्याय है जिसे वह संदर्भित करता है। हार्ड लिंक बनाने के लिए, आपको वेरिएबल से पहले "&" लिखना होगा।

कड़ी कड़ी विज्ञापन का उदाहरण:

$a = 1 ; //   $b = &$a ; // $b   $a echo $b ; // 1 

सब्ज़ द्वारा

हम में से कई ने इस समस्या का सामना किया है: जिस वस्तु को हम एक ही प्रकार की वस्तुओं की एक सरणी से ढूंढ रहे हैं उसे प्राप्त करना आवश्यक है। बेशक, यह एक तुच्छ कार्य है, और इसे एक नियमित चक्र की मदद से आसानी से हल किया जा सकता है, लेकिन मान लीजिए कि हमारे सरणी में तत्वों की एक बड़ी संख्या है। इस मामले में, चक्र का समग्र प्रदर्शन पर हानिकारक प्रभाव पड़ता है। इसके अतिरिक्त, यदि यह कार्य बार-बार किया जाता है, तो यह स्थिति को और बढ़ा देगा।

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

यह स्पष्ट है कि यह समाधान क्या है:

टेस्ट स्क्रिप्ट

यदि आप कोड असेंबली प्रक्रिया को पढ़ना नहीं चाहते हैं तो हम कोड को छोड़ देते हैं और एक पूरे के रूप में देखते हैं

1. हम वस्तुओं का एक परीक्षण सरणी एकत्र करते हैं।

 class Main { public $List = Array(); //     public $Links = Array(); //      public $Count = NULL ; //    public function Fill() //   { for( $i=0; $i < $this->Count; $i++ ) { $Obj = &$this->List[]; //    $Obj = new Obj($i); $Key = md5($i); $this->Links[$Key] = &$Obj; //     } } } class Obj //   { public $Id = NULL; public function __construct( $Id ) { $this->Id = $Id; } } $Main = new Main(); $Main->Count = 1000; //  ,      $Main->Fill(); /*   , print_r( $Main->List ): Array ( [0] => Obj Object ( [Id] => 0 ) [1] => Obj Object ( [Id] => 1 ) [2] => Obj Object ( [Id] => 2 ) ... ) */ 

1. हम आईडी (लूप, और लिंक के माध्यम से) तत्व खोज कार्यों को परिभाषित करते हैं।

 class Main { ... public function Search_Cycle( $Id ) { $Limit = count( $this->List ); for( $i=0; $i < $Limit; $i++ ) if( $this->List[$i]->Id == $Id ) return $this->List[$i]; return NULL; } public function Search_Link( $Id ) { $Key = md5($i); if( isset( $this->Links[$Key] ) == TRUE ) return $this->Links[$Key]; return NULL; } ... } 

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

3. परीक्षण के लिए एक कोड जोड़ें

 ... $Count = 100 ; //        //     10  for( $t=0; $t < $Main->Count; $t++ ) { echo 'Test with ID: ' . $t . ' - started.'; //   ,      $Start = microtime( TRUE ); for( $i=0; $i < $Count; $i++ ) $Main->Search_Cycle( $t ); $Time = round( microtime( TRUE ) - $Start , 4 ); echo '<br />Search_Cycle() time: ' . $Time; //   ,      $Start = microtime( TRUE ); for( $i=0; $i < $Count; $i++ ) $Main->Search_Link( $t ); $Time = round( microtime( TRUE ) - $Start , 4 ); echo '<br /> Search_Link() time: ' . $Time; echo '<br /><br />'; } 

यह कोड इन दो कार्यों का उपयोग करके स्रोत सरणी ( $ गणना समय) के प्रत्येक तत्व की खोज करता है, प्रत्येक के लिए खोज समय की गणना करता है, और परिणाम प्रदर्शित करता है।

एक पूरे के रूप में कोड

अंत में, आपको यह कोड प्राप्त करना चाहिए:

 class Main { public $List = Array(); //     public $Links = Array(); //      public $Count = NULL ; //    public function Fill() //   { for( $i=0; $i < $this->Count; $i++ ) { $Obj = &$this->List[]; //    $Obj = new Obj($i); $Key = md5($i); $this->Links[$Key] = &$Obj; //     } } public function Search_Cycle( $Id ) { $Limit = count( $this->List ); for( $i=0; $i < $Limit; $i++ ) if( $this->List[$i]->Id == $Id ) return $this->List[$i]; return NULL; } public function Search_Link( $Id ) { $Key = md5($Id); if( isset( $this->Links[$Key] ) == TRUE ) return $this->Links[$Key]; return NULL; } } class Obj //   { public $Id = NULL; public function __construct( $Id ) { $this->Id = $Id; } } $Main = new Main(); $Main->Count = 1000; //  ,      $Main->Fill(); /*   , print_r( $Main->List ): Array ( [0] => Obj Object ( [Id] => 0 ) [1] => Obj Object ( [Id] => 1 ) [2] => Obj Object ( [Id] => 2 ) ... ) */ $Count = 100 ; //        //     10  for( $t=0; $t < $Main->Count; $t++ ) { echo 'Test with ID: ' . $t . ' - started.'; //   ,      $Start = microtime( TRUE ); for( $i=0; $i < $Count; $i++ ) $Main->Search_Cycle( $t ); $Time = round( microtime( TRUE ) - $Start , 4 ); echo '<br />Search_Cycle() time: ' . $Time; //   ,      $Start = microtime( TRUE ); for( $i=0; $i < $Count; $i++ ) $Main->Search_Link( $t ); $Time = round( microtime( TRUE ) - $Start , 4 ); echo '<br /> Search_Link() time: ' . $Time; echo '<br /><br />'; } 

परीक्षण के लिए, हमें केवल स्क्रिप्ट चलाने की आवश्यकता है।

परीक्षण

स्क्रिप्ट को चलाकर, परिणाम उस समय के बारे में प्राप्त किया गया था जब तत्व की खोज की गई थी। चूंकि प्रत्येक तत्व को एक पंक्ति में 100 बार (वास्तविक संख्या प्राप्त करने के लिए) खोजा गया था, इसलिए आपके द्वारा नीचे देखे गए किसी भी मूल्य को सबसे यथार्थवादी चित्र प्राप्त करने के लिए एक सौ से विभाजित किया जाना चाहिए।

परिणाम:

रेखांकन पर - खोज की गति। क्षैतिज - वांछित वस्तु की आईडी।

शेड्यूल दुर्भाग्य से एक छवि है, इसलिए आप ट्विच-पॉक नहीं कर सकते।

फ़ंक्शन खोजें Search_Cycle () - एक लूप का उपयोग करना।


Search_Link_Cycle () फ़ंक्शन के साथ खोजें - हार्ड लिंक का उपयोग करना।


इन ग्राफों के अध्ययन में मुख्य बिंदु यह है कि लूप का उपयोग करने वाली खोज लिंक की तुलना में तेजी से काम करती है, जिसमें तत्वों की संख्या 6 से कम (0.002 सेकंड। बनाम 0.004 सेकंड) है।

परिणाम

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

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