परीक्षण के माध्यम से विकास: कौशल में सुधार

पिछले लेख में, हमने सैद्धांतिक पहलुओं की जांच की। यह अभ्यास शुरू करने का समय है।



आइए परीक्षण के माध्यम से विकास का उपयोग करके जावास्क्रिप्ट में स्टैक का एक सरल कार्यान्वयन करें।

स्टैक - एलआईएफओ के सिद्धांत के अनुसार आयोजित एक डेटा संरचना: लास्ट इन, फर्स्ट आउट। स्टैक पर तीन मुख्य ऑपरेशन हैं:

धक्का : आइटम जोड़ें
पॉप : एक आइटम को हटा दें
झांकना : सिर तत्व जोड़ना

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

आइटम : स्टैक पर आइटम। हम स्टैक को लागू करने के लिए एक सरणी का उपयोग करेंगे।
क्षमता : स्टैक क्षमता।
isEmpty () : यदि स्टैक खाली है, तो सही है, अन्यथा सही है।
isFull () : यह सच है अगर स्टैक अधिकतम क्षमता तक पहुँचता है, यानी जब आप एक और तत्व नहीं जोड़ सकते। नहीं तो झूठा लौट आता है।
धक्का (तत्व) : एक तत्व जोड़ता है। यदि स्टैक भरा हुआ है तो पूर्ण रिटर्न देता है।
पॉप : आइटम को हटाता है। यदि स्टैक खाली है, तो खाली हो जाता है।
झांकना () : एक प्रमुख तत्व जोड़ता है।

हम दो फाइलें stack.js और stack.spec.js बनाने जा रहे हैं। मैंने .spec.js एक्सटेंशन का उपयोग किया है क्योंकि मैं इसका उपयोग कर रहा हूं, लेकिन आप .test.js का उपयोग कर सकते हैं या इसे एक अलग नाम दे सकते हैं और इसे __tests__ पर ले जा सकते हैं ।

चूंकि हम परीक्षण के माध्यम से विकास का अभ्यास करते हैं, इसलिए हम एक असफल परीक्षण लिखेंगे।

सबसे पहले, कंस्ट्रक्टर की जांच करें। फ़ाइल का परीक्षण करने के लिए, आपको स्टैक फ़ाइल आयात करने की आवश्यकता है:

const Stack = require('./stack') 

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

जब आप एक क्लास या फ़ंक्शन का परीक्षण कर रहे हों, तो एक परीक्षण चलाएं और बताएं कि आप किस फ़ाइल या क्लास का परीक्षण कर रहे हैं। यह स्टैक के बारे में है:

 describe('Stack', () => { }) 

फिर हमें यह जांचने की आवश्यकता है कि जब स्टैक को आरंभीकृत किया जाता है, तो एक खाली सरणी बनाई जाती है, और हम सही क्षमता निर्धारित करते हैं। तो, हम निम्नलिखित परीक्षण लिखते हैं:

 it('Should constructs the stack with a given capacity', () => { let stack = new Stack(3) expect(stack.items).toEqual([]) expect(stack.capacity).toBe(3) }) 

ध्यान दें कि हम toququal का उपयोग करते हैं और stack.items के लिए toe का उपयोग नहीं करते क्योंकि वे एक ही सरणी का संदर्भ नहीं देते हैं।

अब यार्न टेस्ट स्टैक st.spec.js चलाएं । हम जेस्ट को एक विशिष्ट फ़ाइल में चलाते हैं क्योंकि हम नहीं चाहते कि अन्य परीक्षण दूषित हों। यहाँ परिणाम है:



स्टैक एक कंस्ट्रक्टर नहीं है । बेशक। हमने अभी भी अपना स्टैक नहीं बनाया है और कंस्ट्रक्टर नहीं बनाया है।

Stack.js में अपनी क्लास बनाएं, कंस्ट्रक्टर करें और क्लास को एक्सपोर्ट करें:

 class Stack { constructor() { } } module.exports = Stack 

परीक्षण फिर से चलाएँ:



चूंकि हमने कंस्ट्रक्टर में तत्वों को सेट नहीं किया था, जेस्ट ने सरणी में तत्वों को [] के बराबर होने की उम्मीद की थी, लेकिन वे परिभाषित नहीं थे। फिर आपको तत्वों को इनिशियलाइज़ करना चाहिए:

 constructor() { this.items = [] } 

यदि आप फिर से परीक्षण चलाते हैं, तो आपको क्षमता के लिए वही त्रुटि मिलेगी, इसलिए आपको क्षमता निर्धारित करने की भी आवश्यकता होगी:

 constructor(capacity) { this.items = [] this.capacity = capacity } 

परीक्षण चलाएँ:



हाँ! टेस्ट पास कर लिया । यहां टीडीडी क्या है। मुझे उम्मीद है कि अब परीक्षण आपके लिए और अधिक समझ में आएगा! हम जारी रहेगा?

isEmpty

टेस्ट करने के लिए, खाली है, हम एक खाली स्टैक को इनिशियलाइज़ करने जा रहे हैं, टेस्ट करें कि क्या ईममी सही है या नहीं, एक तत्व जोड़ें और फिर से जाँच करें।

 it('Should have an isEmpty function that returns true if the stack is empty and false otherwise', () => { let stack = new Stack(3) expect(stack.isEmpty()).toBe(true) stack.items.push(2) expect(stack.isEmpty()).toBe(false) }) 

जब आप परीक्षण चलाते हैं, तो आपको निम्न त्रुटि मिलनी चाहिए:

 TypeError: stack.isEmpty is not a function 

इस समस्या को हल करने के लिए, हमें Stack वर्ग के अंदर isEmpty बनाने की आवश्यकता है:

 isEmpty () { } 

यदि आप परीक्षण चलाते हैं, तो आपको एक और त्रुटि मिलनी चाहिए:

 Expected: true Received: undefined 

IsEmpty में कुछ भी नहीं जोड़ा गया है। इसमें कोई तत्व न होने पर स्टैक खाली है:

 isEmpty () { return this.items.length === 0 } 

isFull

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

धक्का

यहां हमें तीन चीजों का परीक्षण करने की आवश्यकता है:

• स्टैक के शीर्ष पर एक नया आइटम जोड़ा जाना चाहिए
• स्टैक भर जाने पर रिटर्न "फुल" लौटाएँ;
• एक आइटम जो हाल ही में जोड़ा गया है उसे वापस किया जाना चाहिए।

पुश के लिए वर्णन का उपयोग करके एक और ब्लॉक बनाएं। हमने इस ब्लॉक को मुख्य के अंदर रखा।

 describe('Stack.push', () => { }) 

आइटम जोड़ें

एक नया स्टैक बनाएं और एक तत्व जोड़ें। आइटम सरणी में अंतिम आइटम आपके द्वारा जोड़े गए आइटम होना चाहिए।

 describe('Stack.push', () => { it('Should add a new element on top of the stack', () => { let stack = new Stack(3) stack.push(2) expect(stack.items[stack.items.length - 1]).toBe(2) }) }) 

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

 push (element) { this.items.push(element) } 

टेस्ट फिर पास हुआ। क्या आपने कुछ नोटिस किया? हम इस पंक्ति की एक प्रति रखते हैं:

 let stack = new Stack(3) 

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

 let stack beforeEach(() => { stack = new Stack(3) }) 

यह महत्वपूर्ण है:

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

महत्वपूर्ण से अधिक महत्वपूर्ण: हमें एक afterEach विधि भी बनानी होगी। स्टैक इंस्टेंस का उपयोग अब सभी परीक्षणों के लिए किया जाएगा। यह कुछ कठिनाइयों का कारण हो सकता है। पहले इस विधि को जोड़ने के तुरंत बाद:

 afterEach(() => { stack.items = [] }) 

अब आप सभी परीक्षणों में स्टैक इनिशियलाइज़ेशन को हटा सकते हैं। यहाँ पूरी परीक्षण फ़ाइल है:

 const Stack = require('./stack') describe('Stack', () => { let stack beforeEach(() => { stack = new Stack(3) }) afterEach(() => { stack.items = [] }) it('Should constructs the stack with a given capacity', () => { expect(stack.items).toEqual([]) expect(stack.capacity).toBe(3) }) it('Should have an isEmpty function that returns true if the stack is empty and false otherwise', () => { stack.items.push(2) expect(stack.isEmpty()).toBe(false) }) describe('Stack.push', () => { it('Should add a new element on top of the stack', () => { stack.push(2) expect(stack.items[stack.items.length - 1]).toBe(2) }) }) }) 

वापसी मूल्य परीक्षण

एक परीक्षण है:

 it('Should return the new element pushed at the top of the stack', () => { let elementPushed = stack.push(2) expect(elementPushed).toBe(2) }) 

जब आप परीक्षण चलाते हैं, तो आपको मिलेगा:

 Expected: 2 Received: undefined 

कुछ भी नहीं अंदर धक्का ! हमें इसे ठीक करना चाहिए:

 push (element) { this.items.push(element) return element } 

स्टैक पूरा भर जाने पर वापस लौटें

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

 it('Should return full if one tries to push at the top of the stack while it is full', () => { stack.items = [1, 2, 3] let element = stack.push(4) expect(stack.items[stack.items.length - 1]).toBe(3) expect(element).toBe('Full') }) 

परीक्षण चलाते समय आपको यह त्रुटि दिखाई देगी:

 Expected: 3 Received: 4 

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

 push (element) { if (this.isFull()) { return 'Full' } this.items.push(element) return element } 

टेस्ट पास कर लिया।

व्यायाम: पॉप और झांकना

यह अभ्यास का समय है। पॉप और झांकना परीक्षण और लागू करें।

टिप्स:

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

इसे स्वयं करने की कोशिश किए बिना नीचे दिए गए समाधान को न देखें। प्रगति का एकमात्र तरीका प्रयास, प्रयोग और अभ्यास है।

निर्णय

खैर, व्यायाम कैसे? क्या आपने किया? यदि नहीं, तो निराश मत होइए। परीक्षण में समय और मेहनत लगती है।

 class Stack { constructor (capacity) { this.items = [] this.capacity = capacity } isEmpty () { return this.items.length === 0 } isFull () { return this.items.length === this.capacity } push (element) { if (this.isFull()) { return 'Full' } this.items.push(element) return element } pop () { return this.isEmpty() ? 'Empty' : this.items.pop() } peek () { return this.isEmpty() ? 'Empty' : this.items[this.items.length - 1] } } module.exports = Stack const Stack = require('./stack') describe('Stack', () => { let stack beforeEach(() => { stack = new Stack(3) }) afterEach(() => { stack.items = [] }) it('Should construct the stack with a given capacity', () => { expect(stack.items).toEqual([]) expect(stack.capacity).toBe(3) }) it('Should have an isEmpty function that returns true if the stack is empty and false otherwise', () => { expect(stack.isEmpty()).toBe(true) stack.items.push(2) expect(stack.isEmpty()).toBe(false) }) it('Should have an isFull function that returns true if the stack is full and false otherwise', () => { expect(stack.isFull()).toBe(false) stack.items = [4, 5, 6] expect(stack.isFull()).toBe(true) }) describe('Push', () => { it('Should add a new element on top of the stack', () => { stack.push(2) expect(stack.items[stack.items.length - 1]).toBe(2) }) it('Should return the new element pushed at the top of the stack', () => { let elementPushed = stack.push(2) expect(elementPushed).toBe(2) }) it('Should return full if one tries to push at the top of the stack while it is full', () => { stack.items = [1, 2, 3] let element = stack.push(4) expect(stack.items[stack.items.length - 1]).toBe(3) expect(element).toBe('Full') }) }) describe('Pop', () => { it('Should removes the last element at the top of a stack', () => { stack.items = [1, 2, 3] stack.pop() expect(stack.items).toEqual([1, 2]) }) it('Should returns the element that have been just removed', () => { stack.items = [1, 2, 3] let element = stack.pop() expect(element).toBe(3) }) it('Should return Empty if one tries to pop an empty stack', () => { // By default, the stack is empty expect(stack.pop()).toBe('Empty') }) }) describe('Peek', () => { it('Should returns the element at the top of the stack', () => { stack.items = [1, 2, 3] let element = stack.peek() expect(element).toBe(3) }) it('Should return Empty if one tries to peek an empty stack', () => { // By default, the stack is empty expect(stack.peek()).toBe('Empty') }) }) }) 

यदि आप फ़ाइलों को देखते हैं, तो आप देखेंगे कि मैंने पॉप और झांकने में ट्रिपल स्थिति का उपयोग किया है। यह वही है जिसे मैंने रिफैक्ट किया था। पुराने कार्यान्वयन इस तरह देखा:

 if (this.isEmpty()) { return 'Empty' } return this.items.pop() 

परीक्षण के माध्यम से विकास हमें परीक्षणों को लिखे जाने के बाद कोड को फिर से भरने की अनुमति देता है, मुझे अपने परीक्षणों के व्यवहार के बारे में चिंता किए बिना एक छोटा कार्यान्वयन मिला।

परीक्षण फिर से चलाएँ:

टेस्ट कोड गुणवत्ता में सुधार करते हैं। मुझे उम्मीद है कि अब आप परीक्षण के पूर्ण लाभों को समझेंगे और अधिक बार टीडीडी का उपयोग करेंगे।

क्या हमने आपको समझा दिया कि परीक्षण महत्वपूर्ण है और कोड की गुणवत्ता में सुधार करता है? बल्कि, परीक्षण के माध्यम से विकास के बारे में लेख के भाग 2 को पढ़ें। और जिन्होंने पहले नहीं पढ़ा था, लिंक का पालन करें ।