मानक PHP लाइब्रेरी (एसपीएल) - भाग 1: डेटा संरचनाएं

हेलो, हेब्र! यह लेख Standard PHP लाइब्रेरी (SPL) के बारे में है। इस लाइब्रेरी के बारे में लाइब्रेरी पर अभी भी कोई समझदार मैनुअल नहीं है, जो पहले से ही PHP कोर (5.3 संस्करण के बाद से) का हिस्सा बन गया है। इस लाइब्रेरी में इंटरफेस, डेटा संरचनाओं की कक्षाएं, पुनरावृत्तियाँ और फ़ंक्शंस हैं, जिनके साथ आप अपने जीवन को सरल बना सकते हैं और कोड की गुणवत्ता में सुधार कर सकते हैं। इस लेख में, मैं पुस्तकालय के ऐसे हिस्से को डेटा संरचनाओं के रूप में मानता हूं। मैं कार्यों के वैकल्पिक समाधान भी दिखाऊंगा और दोनों मामलों में निष्पादन की गति की तुलना करूंगा।


So. सबसे पहले, मैं आधिकारिक दस्तावेज का एक लिंक देना चाहता हूं: php.net/manual/en/book.spl.php
एसपीएल लाइब्रेरी में निम्नलिखित डेटा संरचनाएं शामिल हैं:

• SplDoublyLinkedList - दोगुनी लिंक की गई सूची
• स्प्लिटक - स्टैक
• SplQueue - कतार
• स्प्लेहेप - ढेर
• SplMaxHeap - क्रमबद्ध हीप अवरोही
• SplMinHeap - सॉर्ट हीप आरोही
• SplPriorityQueue - प्राथमिकता कतार
• SplFixedArray - सीमित लंबाई के साथ ऐरे
• SplObjectStorage - ऑब्जेक्ट संग्रहण

क्रम में प्रत्येक संरचना पर विचार करें।

SplDoublyLinkedList

एक दोहरी लिंक की गई सूची (DLL) एक दूसरे के बीच दोनों दिशाओं में जुड़े नोड्स की एक सूची है। जैसा कि आप जानते हैं, सूची से मूल्यों को निकालने के दो सिद्धांत हैं - एफआईएफओ (फर्स्ट इन फर्स्ट आउट - पहले दर्ज किया गया, पहला बाएं) और एलआईएफओ (लास्ट इन फर्स्ट आउट - अंतिम दर्ज किया गया, पहला बाएं)। SplDoublyLinkedList का उपयोग करके, आप इनमें से किसी भी सिद्धांत द्वारा मूल्यों को पुनः प्राप्त कर सकते हैं। इसलिए, इसका उपयोग आसानी से एक स्टैक या कतार को व्यवस्थित करने के लिए किया जा सकता है।

SplStack

यह वर्ग SplDoublyLinkedList का वंशज है और एक ढेर को लागू करता है, उदाहरण के लिए:

$stack = new SplStack(); //     $stack->push('1'); $stack->push('2'); $stack->push('3'); echo $stack->count(); // 3 echo $stack->top(); // 3 echo $stack->bottom(); // 1 echo $stack->serialize(); // i:6;:s:1:"1";:s:1:"2";:s:1:"3"; //     echo $stack->pop(); // 3 echo $stack->pop(); // 2 echo $stack->pop(); // 1 

पहले, हमने बनाने के लिए एक प्रक्रियात्मक विधि का उपयोग किया, अर्थात्, हमने array_push फ़ंक्शन का उपयोग किया - सरणी के अंत में तत्व जोड़ने और array_pop - अंतिम तत्व निकालने। अब हम वस्तुओं के साथ काम कर रहे हैं।

दो तरीकों के प्रदर्शन की तुलना करें। परीक्षण की स्थिति: PHP 5.3.18, कोर 2 डुओ P7350, विंडोज। स्टैक पर 1 से n तक की संख्या जोड़ें और स्टैक से सब कुछ निकालें।

पुश और पॉप की संख्या	क्रियाओं का उपयोग करना	SplStack का उपयोग करना	रवैया
1000	0.007686	0.008559	0.898002
100000	0.793184	0.884979	.८९,६२,७४,३७५

इस परीक्षण में, फ़ंक्शन का उपयोग करने वाली विधि ने लगभग 10-15% तेजी से काम किया।

मनोरंजन के लिए, मैंने PHP 5.4.8 में एक और परीक्षण किया

पुश और पॉप की संख्या	क्रियाओं का उपयोग करना	SplStack का उपयोग करना	रवैया
1000	0.008186	0.008735	.९३,७१,४९,३९९
100000	0.732347	0.771456	.९४,९३,०४,९५१

इस परीक्षण से, आप देख सकते हैं कि PHP 5.4.8 PHP 5.3.18 से तेज है जब स्टैक के साथ लगभग 10% काम करते हैं और वस्तुओं के साथ काम भी बेहतर होता है। इसलिए, मैं PHP के इस संस्करण पर सभी बाद के परीक्षणों का संचालन करूंगा।

हालांकि, यदि अधिक जटिल वस्तुओं को स्टैक में जोड़ा जाता है, तो परिणामों के बीच का अंतर पहले से ही त्रुटि के स्तर पर है।

इस परीक्षण में, हमने स्टैक से निम्नलिखित ऑब्जेक्ट को जोड़ा और पुनर्प्राप्त किया:

 $obj = array("10", "20", "qwerty", "100", array("one", "two", array("100") ) ); 

पुश और पॉप की संख्या	क्रियाओं का उपयोग करना	SplStack का उपयोग करना	रवैया
1000	0.007974	0.008301	.९६,०६,०७,१५६
100000	0.818596	0.826363	.९९,०६,००,९८३

वास्तविक अनुप्रयोगों में, ऑब्जेक्ट बहुत अधिक जटिल होंगे, इसलिए मैं यह मानने की हिम्मत करता हूं कि एसपीएल से विधि का एक महत्वपूर्ण लाभ होगा।

SplQueue

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

 $queue = new SplQueue(); $queue->setIteratorMode(SplQueue::IT_MODE_DELETE); $queue->enqueue('one'); $queue->enqueue('two'); $queue->enqueue('qwerty'); $queue->dequeue(); $queue->dequeue(); echo $queue->top(); // qwerty 

SplHeap

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

SplMaxHeap और SplMinHeap

दो वर्गों SplHeap से विरासत में मिली हैं: SplMaxHeap - अपने मूल्यों के अवरोही क्रम में एक सरणी को छाँटने के लिए, SplMinHeap - आरोही क्रम में एक सरणी छाँटने के लिए।

  $heap = new SplMaxHeap(); $heap->insert('111'); $heap->insert('666'); $heap->insert('777'); echo $heap->extract(); // 777 echo $heap->extract(); // 666 echo $heap->extract(); // 111 $heap = new SplMinHeap(); $heap->insert('111'); $heap->insert('666'); $heap->insert('777'); echo $heap->extract(); // 111 echo $heap->extract(); // 666 echo $heap->extract(); // 777 

SplPriorityQueue

यह संरचना एक प्राथमिकता कतार है। प्रत्येक तत्व के लिए, आप इसकी प्राथमिकता निर्धारित कर सकते हैं। क्रमबद्धता प्राथमिकता के अनुसार की जाती है।

  $queue = new SplPriorityQueue(); $queue->setExtractFlags(SplPriorityQueue::EXTR_DATA); //     $queue->insert('Q', 1); $queue->insert('W', 2); $queue->insert('E', 3); $queue->insert('R', 4); $queue->insert('T', 5); $queue->insert('Y', 6); $queue->top(); while($queue->valid()) { echo $queue->current(); $queue->next(); } //YTREWQ 

SplFixedArray

संरचना तत्वों की एक निश्चित संख्या के साथ एक सरणी है। SplFixedArray एक सतत रूप में डेटा संग्रहीत करता है, अनुक्रमित के माध्यम से पहुँचा जा सकता है, और नियमित सरणियों को आदेशित हैश तालिकाओं के रूप में लागू किया जाता है। इस प्रकार की सरणी नियमित सरणियों की तुलना में तेजी से काम करती है, लेकिन कुछ सीमाएं हैं:

• केवल पूर्णांक> 0 का उपयोग कुंजी के रूप में किया जा सकता है
• लंबाई को बदला जा सकता है, लेकिन यह एक महंगा ऑपरेशन है

यह संरचना गिने सूचियों के लिए अच्छी तरह से अनुकूल है। आइए एक उदाहरण देखें और परीक्षण चलाएं:

  $a = new SplFixedArray(10000); $count = 100000; for($i =0; $i<$count; $i++) { $a[$i] = $i; if ($i==9999) $a->setSize(100000); } 

पुश और पॉप की संख्या	नियमित सरणी	SplFixedArray का उपयोग करना	रवैया
100	8.2 x 10E-5	6.3 x 10E-5	१.३०,१५,८७,३०१
10000	0.004953	0.003983	१.२४,३५,३५,०२४
100000	0.053586	0.0385701	१.३८,९३,१४,५२१
1000000	0.533003	0.384391	१.३८,६६,१६,७५२

परीक्षणों ने पुष्टि की कि किसी भी पूर्व निर्धारित संख्या में सरणी तत्वों के साथ, SplFixedArray सुराग। हालाँकि, अगर इस प्रक्रिया में सरणी का आकार बदल जाता है, तो लाभ कम महत्वपूर्ण हो जाता है: (शुरुआत में आकार 10,000 तक निर्धारित किया गया था, फिर 100,000 तक विस्तारित हुआ):

पुश और पॉप की संख्या	नियमित सरणी	SplFixedArray का उपयोग करना	रवैया
1000000	0.051937	0.049462	१.०५,००,३८,४१३

SplObjectStorage

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

 $s = new SplObjectStorage(); //   $o1 = new StdClass; $o2 = new StdClass; $o3 = new StdClass; $s->attach($o1); //     $s->attach($o2); var_dump($s->contains($o1)); // bool(true) var_dump($s->contains($o2)); // bool(true) var_dump($s->contains($o3)); // bool(false) $s->detach($o2); //     var_dump($s->contains($o1)); // bool(true) var_dump($s->contains($o2)); // bool(false) var_dump($s->contains($o3)); // bool(false) 

एक और उदाहरण:

 $s = new SplObjectStorage(); $o1 = (object)array('a'=>1); $o2 = (object)array('b'=>2); $o3 = (object)array('c'=>3); $s[$o1] = "data for object 1"; $s[$o2] = array(1,2,3); foreach($s as $i => $key) { echo "Entry $i:\n"; // You get a numeric index var_dump($key, $s[$key]); echo "\n"; } 

परिणाम:

 Entry 0: object(stdClass)#2 (1) { ["a"]=> int(1) } string(17) "data for object 1" Entry 1: object(stdClass)#3 (1) { ["b"]=> int(2) } array(3) { [0]=> int(1) [1]=> int(2) [2]=> int(3) } 

यह वह जगह है जहां हमने एसपीएल डेटा संरचनाओं की खोज की। हमने सीखा कि कैसे जल्दी से एक स्टैक, कतार और सूचियों का निर्माण किया जाए। अब हम SplFixedArray के बारे में जानते हैं, जो एक नियमित सरणी से तेज है। हालाँकि, यह इस पुस्तकालय के उपयोग का एक बहुत छोटा हिस्सा है। निम्नलिखित लेख पुनरावृत्तियों, इंटरफेस, फ़ंक्शन और अपवाद हैंडलिंग को कवर करेंगे।