Llst इंटर्नल्स, भाग 1. लघुकटक का परिचय

शुभ दिन। मैं आपका ध्यान निम्न स्तर की स्मालटाक (एलएलएसटी) श्रृंखला के दूसरे लेख पर लाता हूं। जो लोग यह नहीं जानते हैं कि यह किस बारे में है, मैं पिछले समीक्षा लेख को पढ़ने की सलाह देता हूं, जो बताता है कि क्या है और यह क्यों बनाया गया था।

इस भाग में, हम स्मॉलटाक भाषा पर ही ध्यान केंद्रित करेंगे, इसका वाक्यविन्यास और "खेल के नियम"।

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

परिचय

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

तो, स्मालटाक एक सरल भाषा है। एक सरल भाषा न केवल वाक्य रचना के संदर्भ में है, बल्कि एक अप्रस्तुत व्यक्ति द्वारा इसे समझने के संदर्भ में भी है। आश्चर्य की बात नहीं, लेखक ने शुरू में बच्चों की प्रोग्रामिंग सिखाने के लिए एक भाषा के रूप में स्मालटाक को तैनात किया। दुर्भाग्य से, यह एक साथ विकसित नहीं हुआ। बच्चे पीएचपी और बेसिक पसंद करते हैं (या अब वहां क्या फैशनेबल है?)। खैर, हम इसके बारे में बात नहीं करते हैं।

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

वस्तुओं की दुनिया

जावा के बारे में भूल जाओ, सी ++ के बारे में भूल जाओ। सब कुछ भूल जाओ जो तुम्हें सिखाया गया है।

वाक्यांश "भाषा X में, सब कुछ एक वस्तु है" इतना हास्यास्पद है कि मैं यहां इसका उपयोग नहीं करना चाहता था। हालांकि, इस तरह की क्लिच का सहारा लिए बिना स्मालटाक के संबंध में इस विचार की पूरी गहराई का वर्णन करना मुश्किल है।

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

LittleSmalltalk की मूल छवि के वर्णन में ऐसी अद्भुत स्तोत्रिक जगह है :

name subclassOf instanceOf Object MetaObject nil Class MetaClass Object MetaObject Class Class MetaClass Class MetaObject 

यह हमें बताता है कि:

• ऑब्जेक्ट क्लास मेटाऑब्जेक्ट का एक उपवर्ग है और शून्य का एक उदाहरण है (ऑब्जेक्ट्स नोक्सिस्टेंस से आए हैं)
• क्लास क्लास मेटाक्लास का एक उपवर्ग है और वस्तु का एक उदाहरण (सभी वर्ग ऑब्जेक्ट भी हैं)
• क्लास मेटाऑब्जेक्ट क्लास का एक उपवर्ग है और इसका उदाहरण (उह ...)
• मेटाक्लास क्लास मेटाऑब्जेक्ट क्लास के क्लास इंस्टेंस का उपवर्ग है (मेटाक्लास भी क्लासेस हैं)
• विशेषज्ञों का ध्यान दें: लिटिल स्मालटाक में कोई व्यवहार वर्ग नहीं है।

मस्तिष्क विस्फोट? हाँ। लेकिन पूरे वर्ग पदानुक्रम में यह एकमात्र स्थान है जो विरोधाभासी दिखता है। यह विरोधाभासी है। लेकिन इस छोटे पागलपन की कीमत पर महान अवसर प्राप्त होते हैं।

मैं इस जगह को पाठक को डराने के लिए नहीं लाया था, लेकिन यह प्रदर्शित करने के लिए कि स्मॉलटॉक में ताओवादी प्रतीक "यिन और यांग" जैसी कक्षाएं और वस्तुएं, अंतर्विरोधी संस्थाएं हैं।

सादगी के सवाल पर लौटते हुए, मैं ध्यान देता हूं कि यह असंगतता प्रोग्रामिंग में बिल्कुल भी हस्तक्षेप नहीं करती है, और 99% मामलों में प्रोग्रामर इसके बारे में नहीं सोचता (या नहीं जानता)। शेष प्रतिशत मामलों में, यह आपको उन चीजों को करने की अनुमति देता है जो इस भाषा में कार्यक्रमों के ग्रंथों की प्रोग्रामिंग और पढ़ने को बहुत सरल करता है।

छवि

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

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

संदेश की अवधारणा

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

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

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

हालाँकि, यह देखने का सबसे आसान तरीका उदाहरणों के साथ है (इसे कैसे चलाया जाए यह पहले लेख में पाया जा सकता है):

 ->2 + 3 5 

यहां हमने ऑब्जेक्ट 2 लिया और उसे पैरामीटर 3 साथ एक संदेश + भेजा। संदेश का परिणाम एक योग ऑब्जेक्ट है जिसे शेल द्वारा बाहर लौटाया और प्रदर्शित किया गया है। यह एक द्विआधारी संदेश का एक उदाहरण है जिसमें दो ऑब्जेक्ट शामिल हैं।

और यहाँ एक मैसेज का एक उदाहरण है। आइए ऑब्जेक्ट 2 पूछें कि कौन सा वर्ग इससे मेल खाता है। यह एक class संदेश भेजकर किया जाता है:

 ->2 class SmallInt 

बहुत बढ़िया। दोनों SmallInt वर्ग की वस्तु बन गए।

SmallInt वर्ग के और क्या उदाहरण हो सकते SmallInt ? आइए पूछते हैं:

 ->SmallInt listMethods * + - / < = asInteger asSmallInt bitAnd: bitOr: bitShift: hash quo: rem: truncSmallInt SmallInt 

हाँ। ज्ञात + ऑपरेटर और अंकगणितीय संचालन का एक गुच्छा। इस जानकारी को प्राप्त करने के लिए, हमने एक listMethods को listMethods वर्ग में भेजा। यह इसलिए संभव हुआ क्योंकि SmallInt क्लास भी एक वस्तु है, जिसमें संदेश भी भेजे जा सकते हैं। और विरासत के साथ उपरोक्त "साइकेडेलिक" चाल के लिए सभी धन्यवाद। यह ध्यान रखना महत्वपूर्ण है कि कक्षाओं और वस्तुओं को संदेश भेजना उसी तरह से लागू किया जाता है, अर्थात, यह एक ही तंत्र (बिना बैसाखी) है। कक्षाएं और वस्तुएं वास्तव में पास में और किसी भी तरह से एक दूसरे के साथ हस्तक्षेप नहीं करती हैं।

कुछ वस्तुएं क्या हैं?

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

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

अब बात करते हैं नील की । जैसा कि आपने अनुमान लगाया होगा, यह ऑब्जेक्ट एक खाली है, न कि इनिशियलाइज़्ड (या त्रुटिपूर्ण) मान। यह सिर्फ जावा दुनिया से C ++ null पॉइंटर और null विपरीत, nil एक पूर्ण विकसित वस्तु है।

आइए देखें:

 -> 1 isNil false -> nil isNil true -> nil class Undefined 

जैसा कि हम देख सकते हैं, इस वस्तु को संदेश भेजना दूसरों से अलग नहीं है, जो, मुझे ऐसा लगता है, बहुत सुविधाजनक है।

प्रतीकों

एक अन्य महत्वपूर्ण प्रकार की वस्तु प्रतीक है । स्मॉलटाकल में एक प्रतीक एक ऐसी वस्तु है जो अपने गुणों में एक स्ट्रिंग जैसा दिखता है, लेकिन, नील , सच्चे और झूठ की तरह , एक एकल उदाहरण में छवि में मौजूद है।

इस तरह से साधारण रेखाएँ व्यवहार करती हैं:

 ->'hello' = 'hello' true ->'hello' == 'hello' false -> 'hello' + 'World' = 'helloWorld' true -> 'hello' + 'World' == 'helloWorld' false 

यहां, = ऑपरेटर = उपयोग औपचारिक रूप से दो तारों के मूल्यों की तुलना करने के लिए किया जाता है, जबकि == ऑपरेटर पहचान के लिए वस्तुओं की जांच करता है । == ऑपरेटर केवल तभी लौटेगा जब ऑब्जेक्ट और पास किया गया पैरामीटर समान ऑब्जेक्ट होंगे। उपरोक्त मामले में, ऐसा नहीं है, क्योंकि String वर्ग के दो उदाहरणों को पहचान के लिए जांचा जाता है, जो एक के बाद एक बनाए जाते हैं, लेकिन समान वस्तु नहीं हैं।

और यहाँ पात्रों के साथ क्या होता है:

 -> #helloWorld = #helloWorld true -> #helloWorld == #helloWorld true -> ('hello' + 'World') asSymbol == #helloWorld true 

स्मॉलटाक पात्रों के निर्माण को नियंत्रित करता है और यह सुनिश्चित करता है कि वे अपनी विशिष्टता खो न दें। प्रतीकों को आमतौर पर विभिन्न पहचानकर्ताओं, संग्रह में कुंजियों, साथ ही विधि चयनकर्ताओं (नीचे देखें) के रूप में उपयोग किया जाता है।

संदेश भेजना

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

हम कोशिश करते हैं:

 -> Array parent Collection -> Object parent nil -> Array parent isNil false -> Object parent isNil true 

इस उदाहरण में, हम पहले ऐरे और ऑब्जेक्ट कक्षाओं के पूर्वजों को प्रिंट करते हैं, और फिर परिणाम के लिए जाँच करने के लिए एक इस्नील संदेश भेजते हैं। ऑब्जेक्ट क्लास नियमित कक्षाओं के पदानुक्रम में सबसे ऊपर है, इसलिए मूल संदेश के जवाब में, यह शून्य देता है। जैसा कि हम देख सकते हैं, कई संदेशों को संयोजित करने के लिए, उन्हें एक स्थान के साथ लिखना पर्याप्त है। और ऐसी कतारें किसी भी लम्बाई की हो सकती हैं:

 -> 12 12 -> 12 class SmallInt -> 12 class methods Dictionary (* -> Method, + -> Method, - -> Method, / -> Method, < -> Method, = -> Method, asInteger -> Method, asSmallInt -> Method, bitAnd: -> Method, bitOr: -> Method, bitShift: -> Method, hash -> Method, quo: -> Method, rem: -> Method, truncSmallInt -> Method) -> 12 class methods keys OrderedArray (* + - / < = asInteger asSmallInt bitAnd: bitOr: bitShift: hash quo: rem: truncSmallInt) -> 12 class methods keys size 15 

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

नोट: लिटिल स्मॉलटाक में कैस्केडिंग संदेश अब काम नहीं करता है क्योंकि यह मानक कार्यान्वयन में होता है। ऐसा क्यों होता है यह देखा जा सकता है।

मुख्य संदेश

फिलहाल, हम पहले से ही दो प्रकार के संदेशों को जानते हैं: एकात्मक और द्विआधारी। अभी भी प्रमुख संदेश हैं जो एक या अधिक पैरामीटर ले सकते हैं। आइए, पिछले उदाहरण से स्मालइंट क्लास के तरीकों का एक शब्दकोश लें और पूछें कि कौन सी इंडेक्स 7 के तहत कुंजी है:

 -> SmallInt methods keys at: 7 asInteger 

यहां हम keys #at: पैरामीटर 7 को keys ऑब्जेक्ट पर भेजते हैं। #at: में सूचकांक 1 से गिने जाते हैं, इसलिए पहले तत्व में इंडेक्स 1 और अंतिम कंटेनर के आकार के बराबर है।

यहाँ एक महत्वपूर्ण संदेश का एक और उदाहरण दिया गया है:

 -> (Array new: 5) at: 1 put: 42 Array (42 nil nil nil nil) 

सबसे पहले, हमने पैरामीटर 5 के साथ एक सरणी ऑब्जेक्ट पर #new: संदेश भेजकर एक सरणी बनाई, जो तत्वों की संख्या को दर्शाता है। फिर हमने नए बनाए गए एरे में वैल्यू 42 को इंडेक्स 1 पर रखा। परिणामी ऐरे को स्क्रीन पर प्रदर्शित किया गया। ध्यान दें कि शेष 4 कोशिकाएं शून्य मानों से भरी हुई हैं।

मुख्य संदेशों की एक उल्लेखनीय विशेषता यह है कि at: 1 put: 42 एक #at:put: संदेश है #at:put: और दो नहीं, जैसा कि कोई सोच सकता है। सी-जैसी भाषाओं की शैली में, यह keys->atPut(1, 42) के keys->atPut(1, 42) में लिखा जा सकता keys->atPut(1, 42) , हालांकि, इस तरह के रिकॉर्ड में पारित मापदंडों के पत्राचार और उनका उद्देश्य खो जाता है।

मान लें कि हमारे पास एक निश्चित वर्ग Rectangle , जो किसी समतल पर एक आयत का प्रतिनिधित्व करती है। C ++ कोड में, हम इन पंक्तियों में आए:

 Rectangle* rect1 = new Rectangle(200, 100); Rectangle* rect2 = new Rectangle(200, 100, 115, 120, 45); 

कैसे समझें कि संख्याएं किससे मेल खाती हैं? कहते हैं, पहले मामले में, हमारा अनुभव हमें बताएगा कि सबसे अधिक संभावना है कि हम आयत के आकार के बारे में बात कर रहे हैं, और यह कि पहला पैरामीटर एक्स में आकार से मेल खाता है, और दूसरा वाई में। लेकिन यह सुनिश्चित करने के लिए, हमें Rectangle वर्ग के निर्माता के प्रोटोटाइप में देखने की जरूरत है। दूसरा विकल्प भी कम पठनीय लगता है। बेशक, एक अच्छा प्रोग्रामर कोड में टिप्पणी जोड़ देगा और फ़ंक्शन प्रोटोटाइप को बदल देगा ताकि यह Point तरह "बात कर" प्रकारों को स्वीकार करे, लेकिन यह उस बारे में नहीं है।

आइए देखें कि एक समान स्मॉलटॉक निर्माण कैसा दिख सकता है:

 rect1 <- Rectangle width: 200 height: 100. rect2 <- Rectangle new width: 200; height: 100; positionX: 115; positionY: 120; rotationDegrees: 45. 

पहले मामले में, हमने संदेश #width:height: Rectangle वर्ग #width:height: भेजा, जिसने स्वयं का उदाहरण बनाया और इसके मापदंडों से संबंधित फ़ील्ड का मान सेट किया। दूसरे मामले में, हमने सामान्य तरीके से उदाहरण बनाया, संदेश #new भेज रहा है, और फिर मूल्यों को वैकल्पिक रूप से सेट करने के लिए संदेशों का कैस्केडिंग लागू किया। ध्यान दें कि कोड कितना विजुअल बनता है। हमें टिप्पणियों को जोड़ने की भी आवश्यकता नहीं है ताकि पाठक समझ सके कि क्या हो रहा है।

सिद्धांत रूप में, इस कोड को "माथे" लिखा जा सकता है, हालांकि यह कम सुंदर दिखता है:

 " " rect1 <- Rectangle width: 200 height: 100. rect2 <- Rectangle new. " " rect2 width: 200. rect2 height: 100. rect2 positionX: 115. rect2 positionY: 120. rect2 rotationDegrees: 45. 

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

निम्नलिखित कोड उदाहरण पर एक नज़र डालें। यह डिक्शनरी क्लास कोड है जो #keysAsArray: संदेश का जवाब देता है #keysAsArray:

 keysAsArray | index result | result <- Array new: keys size. 1 to: keys size do: [ :index | result at: index put: (keys at: index) ]. ^ result 

इस पद्धति के शरीर में, हम पहले रिटर्न मानों की एक सरणी बनाते हैं, और फिर keys फ़ील्ड की सामग्री के साथ इसे भरते हैं। यहां इकाई #to:do: संदेश #to:do: दो मापदंडों के साथ #to:do: । पहली keys size , और दूसरा कोड का एक टुकड़ा है जिसे निष्पादित करने की आवश्यकता है (वर्ग कोष्ठक में अभिव्यक्ति)। स्मॉलटाकल में, कोड के ऐसे टुकड़ों को ब्लॉक कहा जाता है । बेशक, वे ऑब्जेक्ट हैं और एक चर में संग्रहीत किया जा सकता है। यहां ब्लॉक के लिए वैरिएबल नहीं बनाया गया है, लेकिन इसे तुरंत उपयोग के स्थान पर स्थानांतरित किया जाता है। किसी ब्लॉक को निष्पादित करने के लिए, यह एक संदेश भेजने की जरूरत है #value, या #value: यदि यह एक पैरामीटर स्वीकार करता है। यह वही है जो SmallInt वर्ग अपने #to:do: पद्धति को लागू करने में करेगा।

हमारे मामले में, ब्लॉक को size बार कहा जाएगा, प्रत्येक बार एक पुनरावृत्ति संख्या इसे पारित की जाएगी, जिसे keys से मूल्यों का चयन keys और उन्हें result जोड़ने के लिए एक सूचकांक के रूप में व्याख्या की जाएगी।

वाक्य-विन्यास

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

 METHOD Collection sort ^ self sort: [ :x :y | x < y ] ! METHOD Collection sort: criteria | left right mediane | (self isEmpty) ifTrue: [^self]. mediane <- self popFirst. left <- List new. right <- List new. self do: [ :x | (criteria value: x value: mediane) ifTrue: [ left add: x ] ifFalse: [ right add: x ] ]. left <- left sort: criteria. right <- right sort: criteria. right add: mediane. ^ left appendList: right ! 

Collection वर्ग तत्वों के कुछ सार संग्रह का प्रतिनिधित्व करता है। Collection डेटा को संग्रहित करना नहीं जानता है, यह केवल उन्हें संभालने के लिए सामान्य एल्गोरिदम प्रदान करता है। ऐसा ही एक एल्गोरिथ्म छँटाई कर रहा है।

तो, दिनचर्या में:

 METHOD Collection sort ^ self sort: [ :x :y | x < y ] ! 

यहां हम एक डिफ़ॉल्ट सॉर्टिंग विधि की घोषणा करते हैं जो कोई पैरामीटर नहीं लेता है और अपने साथी को कॉल करता है - #sort विधि: जो एक पैरामीटर के रूप में लेता है जो कुछ मानदंड के आधार पर संग्रह के दो तत्वों की तुलना करता है। हम एक डिफ़ॉल्ट मानदंड प्रदान करते हैं: अधिक-कम अनुपात। हालांकि, जटिल संग्रह आइटम के लिए, कोई भी अतिरिक्त संदेशों को कॉल करने से मना करता है, जैसे x someField < y someField ।

रिकॉर्ड [ :x :y | ब्लॉक के औपचारिक मापदंडों का वर्णन करता है, ^ प्रतीक सी दुनिया से return के बराबर है। self उपयोग self संदेश भेजने के लिए किया जाता है, super का उपयोग किसी के पूर्वज को भेजने के लिए किया जाता है।

आगे बढ़ो:

 sort: criteria | left right mediane | (self isEmpty) ifTrue: [^self]. mediane <- self popFirst. 

#Sort: विधि को एक औपचारिक criteria पैरामीटर के साथ यहां घोषित किया गया है। अगला टेक्स्ट के बाकी हिस्सों से लंबवत लाइनों द्वारा अलग किए गए स्थानीय चर आते हैं। शैली द्वारा, उन्हें एक ही पंक्ति में लिखने की अनुमति है, हालांकि आप उन्हें निम्नलिखित में स्थानांतरित कर सकते हैं:

 sort: criteria | left right mediane | (self isEmpty) ifTrue: [^self]. mediane <- self popFirst. 

फिर हम रिकर्सन बेस की जांच करते हैं। एक खाली संग्रह के मामले में, सॉर्ट का परिणाम भी एक खाली संग्रह होगा।

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

निर्माण (self isEmpty) ifTrue: [^self] मूल रूप से इसके समान किसी भी अन्य से अलग नहीं है। कोष्ठक यहाँ वैकल्पिक हैं और केवल सजावटी उद्देश्यों के लिए डाले गए हैं। सबसे पहले, हम #isEmpty को #isEmpty संदेश भेजते #isEmpty , और फिर इस क्रिया ( Boolean वर्ग के उदाहरणों में से एक) का परिणाम हम संदेश #ifTrue: ब्लॉक पैरामीटर के साथ भेजते हैं, जिसे सही होने पर निष्पादित किया जाना चाहिए।

अंतिम पंक्ति, हम स्थानीय चर माध्यिका को उस वस्तु से #popFirst जो #popFirst संदेश के जवाब में वर्तमान वस्तु को #popFirst । मैंने जानबूझ कर "असाइन" करने के बजाय "बाँध" क्रिया का उपयोग किया था ताकि इस बात पर जोर दिया जा सके कि यहाँ कोई भी नकल नहीं होती है। सभी चर केवल वस्तुओं के संदर्भों को संग्रहीत करते हैं, मूल्यों को नहीं। संग्रह लिंक भी संग्रहीत करते हैं, इसलिए हमें बड़ी मात्रा में डेटा की प्रतिलिपि बनाने के बारे में चिंता नहीं करनी चाहिए। स्पष्ट रूप से ऑब्जेक्ट की एक प्रति बनाने के लिए, पूर्ण या सतही (गैर-पुनरावर्ती) प्रतिलिपि के लिए अलग संदेश प्रदान किए जाते हैं।

कोड का अगला भाग, खुद को छांटना:

  left <- List new. right <- List new. self do: [ :x | (criteria value: x value: mediane) ifTrue: [ left add: x ] ifFalse: [ right add: x ] ]. 

हम उन मदों को संग्रहीत करने के लिए सूचियों की एक जोड़ी बनाते हैं जो संतुष्ट करने वाले और छँटाई वाले मानदंडों को पूरा नहीं करते हैं। परम्परागत रूप से, हम उन्हें "वाम" और "दायें" पड़ाव कहते हैं। फिर हम वर्तमान संग्रह की सामग्री के माध्यम से जाते हैं (विधि #do: , प्रत्येक तत्व ( x ) के लिए हम माध्यिका के साथ तुलना ब्लॉक को कॉल करते हैं और सूची में तत्वों की व्यवस्था करते हैं, तुलना परिणाम के आधार पर।

कृपया ध्यान दें कि ब्लॉक, वास्तव में अलग-अलग ऑब्जेक्ट हैं, शांति से उपरोक्त घोषित चर तक पहुंचते हैं। तो, #do: अंदर का ब्लॉक #do: mediane चर का उपयोग करता है, जबकि #ifTrue: पर ब्लॉक #ifTrue: दोनों x चर और left को संदर्भित करता है, पदानुक्रम में और भी अधिक घोषित। यह संभव है क्योंकि स्मॉलटाक में ब्लॉक क्लोजर हैं और उनके उपयोग के शाब्दिक संदर्भ से बंधा हुआ है।

अंत में, शेष विधि:

  left <- left sort: criteria. right <- right sort: criteria. right add: mediane. ^ left appendList: right 

हम प्राप्त किए गए भागों को पुन: क्रमबद्ध करते हैं, और फिर छंटे हुए बाएं, मध्य और क्रमबद्ध दाएं भागों को एक सूची में जोड़ते हैं, जिन्हें हम छंटाई के परिणामस्वरूप वापस करते हैं।

अब देखते हैं कि छंटाई का उपयोग कैसे किया जा सकता है:

 " " -> #(13 0 -6 221 64 7 -273 42 1024) sort Array (-273 -6 0 7 13 42 64 221 1024) "  " -> #(13 0 -6 221 64 7 -273 42 1024) sort: [ :x :y | x > y ] Array (1024 221 64 42 13 7 0 -6 -273) " " -> #(13 0 -6 221 64 7 -273 42 1024) sort: [ :x :y | x asString < y asString ] Array (-273 -6 0 1024 13 221 42 64 7) "    " -> #(13 0 -6 221 64 7 -273 42 1024) sort: [ :x :y | x asString size < y asString size ] Array (7 0 13 -6 42 64 221 1024 -273) "   " ->' ,     !' words List ( ,     !) "        " ->' ,     !' words sort: [ :x :y | x size < y size ] List (   !  , ) 

इस प्रकार, किसी भी प्रकार के डेटा को संसाधित करने के लिए एक एकल सामान्यीकृत एल्गोरिदम का सफलतापूर्वक उपयोग किया जा सकता है। यह सही मानदंड निर्धारित करने के लिए पर्याप्त है।

सूचियों

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

इसलिए, सूची के प्रमुख में डेटा जोड़ने का सबसे तेज़ तरीका है:

 METHOD List add: anElement elements <- Link value: anElement next: elements. ^ anElement ! 

हम बस तत्व क्षेत्र में एक नई वस्तु जोड़ते हैं, इसे वर्तमान मूल्य के साथ जोड़ते हैं और नए तत्व के साथ जिसे संग्रहीत करने की आवश्यकता होती है।

सूची की पूंछ में एक तत्व जोड़ना अधिक जटिल है, क्योंकि हमें पहले वहां पहुंचने की आवश्यकता है:

 METHOD List addLast: anElement elements isNil ifTrue: [ self add: anElement ] ifFalse: [ elements addLast: anElement ]. ^ anElement ! METHOD Link addLast: anElement next notNil ifTrue: [ ^ next addLast: anElement ] ifFalse: [ next <- Link value: anElement ] ! 

इस अर्थ में, स्मालटाक सूचियाँ हास्केल भाषा में संबंधित संरचनाओं से मिलती-जुलती हैं (ज़ाहिर है, हास्केल में सूची की समरूपता की आवश्यकता शून्य)। इस स्थिति में, ऑपरेटर :#add से मेल खाता है: और ऑपरेटर ++मेल खाता है #addLast:।

अंत में, #appendList: विधि जल्दी से दो सूचियों को एक में बाँधती है। वह पहली सूची का अंत पाता है और दूसरे को उसमें चिपका देता है:

 METHOD List appendList: aList | element | (elements isNil) ifTrue: [ elements <- aList firstLink. ^self ]. element <- elements. [element next isNil] whileFalse: [element <- element next]. element next: aList firstLink. ^self ! 

यह एक-एक करके पुन: आइटम जोड़ने से तेज है।

निष्कर्ष

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

जारी रखा जा करने के लिए :)

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