कितने बड़े गैर-OO कोड आधार प्रबंधित किए जाते हैं?

27

मैं हमेशा देखता हूं कि अमूर्त एक बहुत ही उपयोगी सुविधा है जो OO कोड-बेस के प्रबंधन के लिए प्रदान करता है। लेकिन बड़े गैर-ओओ कोड आधार कैसे प्रबंधित किए जाते हैं? या क्या वे अंततः " बिग बॉल ऑफ मड " बन जाते हैं?

अद्यतन:
ऐसा लगता था कि हर कोई सोच रहा है 'अमूर्तता' केवल संशोधन या डेटा-छिपाना है। लेकिन IMHO, इसका मतलब 'एब्सट्रैक्ट क्लासेस' या 'इंटरफेसेस' का उपयोग भी है, जो निर्भरता-इंजेक्शन के लिए आवश्यक है और इस प्रकार परीक्षण करना चाहिए। गैर-OO कोड आधार इसे कैसे प्रबंधित करते हैं? और इसके अलावा, अमूर्तता के अलावा, इनकैप्सुलेशन भी बड़े कोड आधारों को प्रबंधित करने में बहुत मदद करता है क्योंकि यह डेटा और फ़ंक्शंस के बीच संबंध को परिभाषित और प्रतिबंधित करता है।

C के साथ, छद्म-OO कोड लिखना बहुत संभव है। मैं अन्य गैर-ओओ भाषाओं के बारे में ज्यादा नहीं जानता। तो, क्या यह बड़े C कोड आधारों को प्रबंधित करने का तरीका है?

project-management object-oriented

— गुलशन
स्रोत

6

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

— टिम पोस्ट

भाषा-अज्ञेय तरीके से, कृपया वर्णन करें कि आप कोड बेस को कैसे प्रबंधित करते हुए देखते हैं, और ओओ को इसके साथ क्या करना है।

— डेविड थॉर्नले

@ समय पोस्ट मुझे लिनक्स कर्नेल स्रोत कोड प्रबंधन के बारे में दिलचस्पी है। क्या आप कृपया सिस्टम का अधिक वर्णन करेंगे? शायद एक उदाहरण के साथ एक उत्तर के रूप में?

— गुलशन

7

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

— 4

मुझे लगता है कि यह "प्रबंधित" के रूप में बड़े कोड बेस (OO या अन्यथा) को संदर्भित करने के लिए एक खिंचाव है। आपके प्रश्न में केंद्रीय शब्द की बेहतर परिभाषा होना अच्छा होगा।

— 31'11

43

आपको लगता है कि OOP अमूर्तता प्राप्त करने का एकमात्र साधन है।

जबकि ओओपी निश्चित रूप से ऐसा करने में बहुत अच्छा है, यह किसी भी तरह से एकमात्र तरीका नहीं है। बड़ी परियोजनाओं को भी अप्रतिस्पर्धी संशोधन द्वारा प्रबंधित किया जा सकता है (बस पर्ल या पायथन को देखें, दोनों ने उस पर उत्कृष्ट प्रदर्शन किया है, और इसलिए एमएल और हास्केल जैसी कार्यात्मक भाषाएं करते हैं), और टेम्प्लेट जैसे तंत्र का उपयोग करके (C ++ में)।

— कोनराड रुडोल्फ
स्रोत

27

+1 इसके अलावा, यदि आप नहीं जानते कि आप क्या कर रहे हैं, तो ओओपी का उपयोग करके "बिग बॉल ऑफ मड" लिखना संभव है।

— लैरी कोलमैन

C कोड बेस के बारे में क्या?

— गुलशन

6

@ गुलशन: कई बड़े C कोड बेस OOP हैं। सिर्फ इसलिए कि C में कक्षाएं नहीं हैं, इसका मतलब यह नहीं है कि OOP को थोड़े प्रयास से हासिल नहीं किया जा सकता है। इसके अलावा, सी हेडर और PIMPL मुहावरे का उपयोग करते हुए एक अच्छे संशोधन की अनुमति देता है। आधुनिक भाषाओं में मॉड्यूल के रूप में लगभग आरामदायक या शक्तिशाली नहीं है, लेकिन एक बार फिर काफी अच्छा है।

— कोनराड रुडोल्फ

9

सी फ़ाइल स्तर पर संशोधन की अनुमति देता है। इंटरफ़ेस। H फ़ाइल में जाता है, सार्वजनिक रूप से उपलब्ध कार्यों में .c फ़ाइल, और निजी चर और फ़ंक्शंस में staticपहुँच संशोधक संलग्न होता है।

— डेविड थॉर्नले

1

@ कोनराड: जबकि मैं मानता हूं कि ओओपी केवल ऐसा करने का एकमात्र तरीका नहीं है, मेरा मानना है कि ओपी शायद कड़ाई से सी को ध्यान में रखते थे, जो न तो एक कार्यात्मक और न ही एक गतिशील भाषा है। इसलिए मुझे संदेह है कि पर्ल और हास्केल का उल्लेख उसके / उसके लिए किसी काम का होगा। मुझे वास्तव में आपकी टिप्पणी ओपी के लिए अधिक प्रासंगिक और उपयोगी लगती है ( इसका मतलब यह नहीं है कि ओओपी को थोड़े प्रयास से हासिल नहीं किया जा सकता है ); आप इसे अतिरिक्त विवरण के साथ एक अलग उत्तर के रूप में जोड़ने पर विचार कर सकते हैं, शायद एक कोड स्निपेट या कुछ लिंक के साथ समर्थित है। यह कम से कम मेरा वोट जीत सकता है, और संभवतः ओपी का। :)

— ग्रू

11

मॉड्यूल, (बाहरी / आंतरिक) कार्य, सबरूटीन्स ...

जैसा कि कोनराड ने कहा, OOP बड़े कोड बेस को प्रबंधित करने का एकमात्र तरीका नहीं है। तथ्य की बात के रूप में, सॉफ्टवेयर का एक बहुत कुछ इसके पहले (C ++ * से पहले) लिखा गया था।

— कौआ
स्रोत

* और हाँ, मुझे पता है कि C ++ केवल OOP का समर्थन करने वाला ही नहीं है, बल्कि किसी भी तरह जब उस दृष्टिकोण ने जड़ता लेना शुरू कर दिया।

— Rook

8

मॉड्यूलरिटी सिद्धांत ऑब्जेक्ट-ओरिएंटेड भाषाओं तक सीमित नहीं है।

— पॉल नाथन
स्रोत

6

वास्तविक रूप से या तो अनंतिम परिवर्तन (सामाजिक सुरक्षा सेवानिवृत्ति गणना सोचें) और / या गहन रूप से निपुण ज्ञान क्योंकि सिस्टम को बनाए रखने वाले लोग कुछ समय के लिए ऐसा कर रहे हैं (सनकी लेना नौकरी की सुरक्षा है)।

बेहतर समाधान दोहराए जाने योग्य सत्यापन हैं, जिनके द्वारा मेरा मतलब है स्वचालित परीक्षण (जैसे इकाई परीक्षण) और मानव परीक्षण जो कि चरणबद्ध (उदाहरण प्रतिगमन परीक्षण) का अनुसरण करता है "जैसा कि चारों ओर क्लिक करने और देखने के लिए कि क्या टूटता है"।

किसी मौजूदा कोडबेस के साथ कुछ प्रकार के स्वचालित परीक्षण की ओर बढ़ना शुरू करने के लिए, मैं माइकल फेदर की वर्किंग को प्रभावी रूप से लिगेसी कोड के साथ पढ़ने की सलाह देता हूं , जो कि मौजूदा कोडबेस को किसी प्रकार के दोहराए जाने वाले परीक्षण ढांचे के ओओ तक या नहीं तक पहुंचने के लिए विवरण देता है। यह उन विचारों के प्रकार की ओर ले जाता है, जिनका दूसरों ने उत्तर दिया है जैसे कि मॉडर्नाइजेशन, लेकिन पुस्तक चीजों को न तोड़ते हुए ऐसा करने के लिए सही दृष्टिकोण का वर्णन करती है।

— orangepips
स्रोत

माइकल फेदर की किताब के लिए +1। जब आप एक बड़े बदसूरत कोड-बेस के बारे में उदास महसूस करते हैं, (इसे पुनः पढ़ें) :)

— Matthieu

5

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

मैंने मेटाडेटा के साथ कठोर होने के लिए बहुत मददगार पाया है। OO भाषाओं में, कोड के बिट्स के बीच संबंधों को वर्ग संरचना द्वारा परिभाषित (एक हद तक), एक तरह से मानकीकृत किया जाता है ताकि प्रतिबिंब एपीआई जैसी चीजें हो सकें। प्रक्रियात्मक भाषाओं में यह उन लोगों का आविष्कार करने में सहायक हो सकता है।

मैंने यह भी पाया है कि एक पीढ़ीगत भाषा (एक वस्तु उन्मुख भाषा की तुलना में) में कोड पीढ़ी बहुत अधिक सहायक है। यह गारंटी देता है कि मेटा-डेटा कोड के साथ समानार्थी है (क्योंकि इसका उपयोग इसे उत्पन्न करने के लिए किया जाता है) और आपको पहलू उन्मुख प्रोग्रामिंग के कट पॉइंट जैसे कुछ देता है - एक जगह थी जिसे आप आवश्यकता होने पर कोड इंजेक्ट कर सकते हैं। कभी-कभी यह ऐसे वातावरण में DRY प्रोग्रामिंग करने का एकमात्र तरीका है जिसे मैं समझ सकता हूं।

— psr
स्रोत

3

वास्तव में, जैसा कि आपने हाल ही में खोजा है , पहले क्रम के कार्य आप सभी पर निर्भरता के लिए आवश्यक हैं।

C पहले आदेश कार्यों का समर्थन करता है और यहां तक कि कुछ हद तक बंद भी करता है । और सी मैक्रोस जेनेरिक प्रोग्रामिंग के लिए एक शक्तिशाली विशेषता है, यदि आवश्यक देखभाल के साथ संभाला जाता है।

यह सब वहाँ है। अत्यधिक पुन: प्रयोज्य कोड लिखने के लिए C का उपयोग कैसे किया जा सकता है, इस पर SGLIB काफी अच्छा उदाहरण है। और मेरा मानना है कि वहाँ बहुत कुछ है।

— डीओएस
स्रोत

2

अमूर्तता के बिना भी, अधिकांश कार्यक्रमों को किसी प्रकार के खंडों में तोड़ दिया जाता है। वे खंड आमतौर पर विशिष्ट कार्यों या गतिविधियों से संबंधित होते हैं और आप उसी तरह से काम करते हैं जिस तरह से आप अमूर्त कार्यक्रमों के सबसे विशिष्ट बिट्स पर काम करेंगे।

छोटे से मध्यम आकार की परियोजनाओं में वास्तव में ऐसा करना आसान होता है जो कभी-कभी शुद्ध OO कार्यान्वयन के साथ होता है।

— बिल
स्रोत

2

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

गैर-ओओपी को कोड करते समय मुख्य रहस्य ओओपी से बचने के लिए है।

गैर-ओओ भाषाओं में मॉड्यूलरिटी प्रमुख है। सी में यह केवल डेविड थोर्नली द्वारा एक टिप्पणी में उल्लिखित के रूप में हासिल किया गया है:

इंटरफ़ेस .h फ़ाइल में जाता है, सार्वजनिक रूप से उपलब्ध .c फ़ाइल में कार्य करता है, और निजी चर और फ़ंक्शन स्थिर एक्सेस संशोधक को संलग्न करते हैं।

— mouviciel
स्रोत

1

एमवीसी (मॉडल-व्यू-कंट्रोलर) आर्किटेक्चर की तर्ज पर कोड के प्रबंधन का एक तरीका इसे निम्न प्रकार के कोड में बदलना है।

इनपुट हैंडलर - यह कोड माउस, कीबोर्ड, नेटवर्क पोर्ट, या सिस्टम इवेंट जैसे उच्च-स्तरीय अमूर्त जैसे इनपुट डिवाइस से संबंधित है।
आउटपुट हैंडलर - यह कोड बाहरी उपकरणों जैसे कि मॉनिटर, लाइट, नेटवर्क पोर्ट, आदि में हेरफेर करने के लिए डेटा का उपयोग करने से संबंधित है।
मॉडल - यह कोड आपके लगातार डेटा की संरचना को घोषित करने, लगातार डेटा को मान्य करने के नियम, और डिस्क (या अन्य लगातार डेटा डिवाइस) के लिए लगातार डेटा को सहेजने से संबंधित है।
दृश्य - यह कोड विभिन्न ब्राउज़रों जैसे कि वेब ब्राउज़र (HTML / CSS), GUI, कमांड लाइन, संचार प्रोटोकॉल डेटा प्रारूप (जैसे JSON, XML, ASN.1, आदि) की आवश्यकताओं को पूरा करने के लिए डेटा स्वरूपण से संबंधित है।
एल्गोरिदम - यह कोड जितनी जल्दी हो सके एक इनपुट डेटा को आउटपुट डेटा सेट में बदल देता है।
नियंत्रकों - यह कोड इनपुट हैंडलर के माध्यम से इनपुट लेता है, एल्गोरिदम का उपयोग करके इनपुट को पार्स करता है, और फिर डेटा को लगातार डेटा के साथ इनपुट के संयोजन द्वारा या अन्य इनपुट को बदलकर, और फिर वैकल्पिक रूप से मॉडल के माध्यम से लगातार डेटा को बदलकर डेटा को बदल देता है। सॉफ्टवेयर, और वैकल्पिक रूप से आउटपुट डिवाइस पर रेंडर करने के लिए व्यू सॉफ्टवेयर के माध्यम से डेटा को बदलना।

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

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

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

— जय गोडसे
स्रोत

0

जब ऐसी भाषाओं में काम करना जिसमें इनबिल्ट स्ट्रक्चर और ऑर्गनाइजेशन फीचर्स की कमी हो (जैसे कि अगर इसमें नेमस्पेस, पैकेज, असेंबली आदि नहीं हैं ...) या जहां ये उस आकार के कोडबेस को नियंत्रण में रखने के लिए अपर्याप्त हैं, तो स्वाभाविक प्रतिक्रिया विकसित करना है कोड को व्यवस्थित करने के लिए हमारी अपनी रणनीतियाँ।

इस संगठन की रणनीति में संभवतः अलग-अलग फाइलें शामिल हैं, जहाँ विभिन्न फ़ाइलों को रखा जाना चाहिए, कुछ प्रकार के कार्यों से पहले / बाद में होने वाली ज़रूरतों, और सम्मेलनों और अन्य कोडिंग मानकों के नामकरण के साथ-साथ बहुत सारे "यह है कि इसे कैसे सेट किया जाता है" - इसके साथ गड़बड़ मत करो! टिप्पणी टाइप करें - जो तब तक मान्य हैं जब तक वे समझाते हैं कि क्यों!

चूँकि रणनीति परियोजना के विशिष्ट आवश्यकताओं (लोगों, प्रौद्योगिकियों, पर्यावरण आदि ...) के अनुरूप होने की संभावना है, इसलिए बड़े कोड आधारों को प्रबंधित करने के लिए एक आकार-फिट-सभी समाधान देना कठिन है।

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

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

रीफैक्टरिंग के लिए तर्क समान है: आप सिस्टम के छोटे हिस्सों पर काम करने की दिशा में एक मानसिक अवरोध विकसित करेंगे यदि आपको लगता है कि इसका समग्र संगठन गड़बड़ है, और अंततः इसे बिगड़ने देगा (कम से कम यह मेरा काम है यह)।

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

मैं मानता हूं कि प्रत्यक्ष कोड को रिफलेक्ट करने की तुलना में बहुत पेचीदा है, और प्रबंधकों / ग्राहकों से समय को मान्य / छिपाना कठिन है जो समझ नहीं पा रहे हैं कि ऐसा करने की आवश्यकता क्यों है, लेकिन ये भी सॉफ्टवेयर रोट के लिए सबसे अधिक संभावना वाले प्रोजेक्ट हैं अनम्य शीर्ष स्तर के डिजाइन के कारण ...

— AndyHasIt
स्रोत

0

यदि आप किसी बड़े कोड-बेस के प्रबंधन के बारे में पूछ रहे हैं, तो आप यह पूछ रहे हैं कि अपने कोड आधार को अपेक्षाकृत मोटे स्तर पर कैसे ठीक रखा जाए (उप-प्रणालियों के पुस्तकालयों / मॉड्यूल / भवन / नामस्थानों का उपयोग करके / सही स्थानों पर सही डॉक्स होने के लिए। आदि।)। OO सिद्धांत, विशेष रूप से 'अमूर्त वर्ग' या 'इंटरफेस', आपके कोड को आंतरिक रूप से, बहुत विस्तृत स्तर पर साफ रखने के सिद्धांत हैं। इस प्रकार, एक बड़े कोड आधार को प्रबंधनीय रखने की तकनीकें OO या गैर OO- कोड के लिए भिन्न नहीं होती हैं।

— डॉक्टर ब्राउन
स्रोत

0

यह कैसे संभाला जाता है कि आप अपने द्वारा उपयोग किए जाने वाले तत्वों की सीमाओं का पता लगा लें। उदाहरण के लिए, C ++ में निम्नलिखित तत्वों की एक स्पष्ट सीमा है और सीमा के बाहर किसी भी निर्भरता को सावधानीपूर्वक सोचा जाना चाहिए:

मुफ्त समारोह
सदस्य समारोह
कक्षा
वस्तु
इंटरफेस
अभिव्यक्ति
कंस्ट्रक्टर कॉल / ऑब्जेक्ट बनाना
फ़ंक्शन कॉल
टेम्पलेट पैरामीटर प्रकार

इन तत्वों को मिलाकर और उनकी सीमाओं को पहचानकर, आप लगभग कोई भी प्रोग्रामिंग शैली बना सकते हैं जिसे आप c ++ में चाहते हैं।

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

— रेव्स tp1
स्रोत

-1

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

— जोनाथन क्लाइन आईईईई
स्रोत

-2

Emacs इसका एक अच्छा उदाहरण है:

Emacs लिस्प परीक्षण उपयोग skip-unlessऔर let-bindसुविधा का पता लगाने और परीक्षण जुड़नार करने के लिए:

कभी-कभी, लापता पूर्व शर्त के कारण परीक्षण चलाने का कोई मतलब नहीं है। एक आवश्यक Emacs सुविधा को संकलित नहीं किया जा सकता है, परीक्षण किए जाने वाले फ़ंक्शन को एक बाहरी बाइनरी कॉल किया जा सकता है जो परीक्षण मशीन पर उपलब्ध नहीं हो सकता है, आप इसे नाम देते हैं। इस मामले में, skip-unlessपरीक्षण को छोड़ने के लिए मैक्रो का उपयोग किया जा सकता है:

 (ert-deftest test-dbus ()
   "A test that checks D-BUS functionality."
   (skip-unless (featurep 'dbusbind))
   ...)

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

परीक्षणों को पर्यावरण पर निर्भर नहीं होना चाहिए क्योंकि ऐसी कोई भी निर्भरता परीक्षण को भंगुर बना सकती है या विफलताओं को जन्म दे सकती है जो केवल कुछ परिस्थितियों में होती हैं और पुन: पेश करना मुश्किल होता है। बेशक, परीक्षण के तहत कोड में ऐसी सेटिंग्स हो सकती हैं जो उसके व्यवहार को प्रभावित करती हैं। उस मामले में, परीक्षण let-bindकी अवधि के लिए विशिष्ट कॉन्फ़िगरेशन सेट करने के लिए परीक्षण को ऐसे सभी सेटिंग चर बनाने के लिए सबसे अच्छा है । परीक्षण कई अलग-अलग कॉन्फ़िगरेशन भी सेट कर सकता है और प्रत्येक के साथ परीक्षण के तहत कोड चला सकता है।

जैसा कि SQLite है। यहाँ यह डिजाइन है:

sqlite3_open () → एक नए या मौजूदा SQLite डेटाबेस के लिए एक कनेक्शन खोलें। Sqlite3 के लिए निर्माता।
sqlite3 → डेटाबेस कनेक्शन ऑब्जेक्ट। Sqlite3_open () द्वारा बनाया गया और sqlite3_close () द्वारा नष्ट कर दिया गया।
sqlite3_stmt → तैयार कथन वस्तु। Sqlite3_prepare () द्वारा बनाया गया और sqlite3_finalize () द्वारा नष्ट कर दिया गया।
sqlite3_prepare () → SQL टेक्स्ट को बाइट-कोड में संकलित करें जो डेटाबेस को क्वेरी या अपडेट करने का काम करेगा। Sqlite3_stmt के लिए निर्माता।
sqlite3_bind () → मूल एसक्यूएल के मापदंडों में एप्लिकेशन डेटा स्टोर करें।
sqlite3_step () → अगली परिणाम पंक्ति या पूरा होने के लिए एक sqlite3_stmt अग्रिम करें।
sqlite3_column () → एक sqlite3_stmt के लिए वर्तमान परिणाम पंक्ति में कॉलम मान।
sqlite3_finalize () → sqlite3_stmt के लिए विध्वंसक।
sqlite3_exec () → एक रैपर फ़ंक्शन जो sqlite3_prepare (), sqlite3_step (), sqlite3_column (), और sqlite3_finalize () एक या अधिक SQL कथनों के स्ट्रिंग के लिए करता है।
sqlite3_close () → sqlite3 के लिए विनाशकारी।

टोकनर, पार्सर और कोड जेनरेटर घटकों का उपयोग SQL कथनों को संसाधित करने और उन्हें वर्चुअल मशीन भाषा या बाइट कोड में निष्पादन योग्य कार्यक्रमों में बदलने के लिए किया जाता है। मोटे तौर पर, ये शीर्ष तीन परतें sqlite3_prepare_v2 () को लागू करती हैं । शीर्ष तीन परतों द्वारा उत्पन्न बाइट कोड एक तैयार विवरण है। वर्चुअल मशीन मॉड्यूल SQL स्टेटमेंट बाइट कोड को चलाने के लिए जिम्मेदार है। बी-ट्री मॉड्यूल आदेशित कुंजियों और लॉगरिदमिक प्रदर्शन के साथ कई कुंजी / मान स्टोर में एक डेटाबेस फ़ाइल का आयोजन करता है। पेजर मॉड्यूल डेटाबेस फ़ाइल के पृष्ठों को मेमोरी में लोड करने, लेन-देन को लागू करने और नियंत्रित करने के लिए और एक क्रैश या पावर विफलता के बाद डेटाबेस भ्रष्टाचार को रोकने वाली जर्नल फ़ाइलों को बनाने और बनाए रखने के लिए जिम्मेदार है। OS इंटरफ़ेस एक पतली अमूर्तता है जो SQLite को अलग-अलग ऑपरेटिंग सिस्टम पर चलाने के लिए बदलने के लिए दिनचर्या का एक सामान्य सेट प्रदान करता है। मोटे तौर पर, नीचे की चार परतें sqlite3_step () को लागू करती हैं ।

वर्चुअल टेबल एक ऐसी वस्तु है जो एक खुले SQLite डेटाबेस कनेक्शन के साथ पंजीकृत है। SQL कथन के परिप्रेक्ष्य से, वर्चुअल टेबल ऑब्जेक्ट किसी अन्य तालिका या दृश्य की तरह दिखता है। लेकिन वर्चुअल टेबल पर पर्दे, प्रश्नों और अपडेट के पीछे डेटाबेस फ़ाइल पर पढ़ने और लिखने के बजाय वर्चुअल टेबल ऑब्जेक्ट के कॉलबैक तरीकों को आमंत्रित करता है।

एक वर्चुअल टेबल एक इन-मेमोरी डेटा संरचनाओं का प्रतिनिधित्व कर सकती है। या यह उस डिस्क पर डेटा का एक दृश्य प्रस्तुत कर सकता है जो SQLite प्रारूप में नहीं है। या एप्लिकेशन मांग पर वर्चुअल टेबल की सामग्री की गणना कर सकता है।

वर्चुअल टेबल के लिए कुछ मौजूदा और पोस्ट किए गए उपयोग इस प्रकार हैं:

एक पूर्ण-पाठ खोज इंटरफ़ेस
R-Trees का उपयोग कर स्थानिक सूचकांक
किसी SQLite डेटाबेस फ़ाइल (dbstat वर्चुअल टेबल) की डिस्क सामग्री का निरीक्षण करें
अल्पविराम से अलग मूल्य (CSV) फ़ाइल की सामग्री को पढ़ें और / या लिखें
होस्ट कंप्यूटर के फाइल सिस्टम को एक्सेस करें जैसे कि यह एक डेटाबेस टेबल था
R जैसे सांख्यिकी पैकेज में डेटा के SQL हेरफेर को सक्षम करना

विभिन्न प्रकार की परीक्षण तकनीकों का SQLite उपयोग:

तीन स्वतंत्र रूप से विकसित परीक्षण हार्नेस
एक के रूप में तैनात विन्यास में 100% शाखा परीक्षण कवरेज
लाखों और लाखों परीक्षण मामले
स्मृति परीक्षण के बाहर
I / O त्रुटि परीक्षण
क्रैश और पावर लॉस टेस्ट
फज टेस्ट
सीमा मूल्य परीक्षण
विकलांग अनुकूलन परीक्षण
प्रतिगमन परीक्षण
विकृत डेटाबेस परीक्षण
मुखर () और रन-टाइम चेक का व्यापक उपयोग
वैलग्राइंड विश्लेषण
अपरिभाषित व्यवहार की जाँच
जाँच सूची

संदर्भ

— पॉल स्वेट को दर्शाता है
स्रोत