स्मॉलटॉक में ऐरे और लिटल ऐरे के बीच क्या अंतर है? आकार के अलावा

Question

।

उदाहरण के लिए:

|arr|. arr := Array new: 10 

और

#(element1,element2, ...) 

Answer 1

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

doSomething 
    array := #(6 7 8). 
    Transcript show: array. 
    array at: 1 put: 3. 

पहली बार जब आप निष्पादित DoSomething सब कुछ सामान्य हो जाएगा:

निम्नलिखित कोड पर विचार करें। दूसरी बार आपको 3, 7, 8 मुद्रित मिलेगा, क्योंकि सरणी वही है जो पिछली बार विधि लागू होने पर संशोधित की गई थी।

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

Answer 2

एक उदाहरण चर सीमा के साथ एक उदाहरण कक्षा में इस विधि पर विचार करें:

Example >> #threshold 
    ^threshold 
Example >> #threshold: anInteger 
    threshold := anInteger 
Example >> #initialize 
    threshold := 0 
Example class >> #new 
    ^super new initialize 

Example >> testArraySum 
    | a | 
    a := #(4 8 10). 
    a sum > threshold ifTrue: [ a at: 1 put: a first - 2 ]. 
    ^a sum 

अब, अगर आप testArraySum के कोड को पढ़ने के लिए, अगर सीमा नहीं करता परिवर्तन, यह हमेशा एक ही है, shouldn' retunr चाहिए यह नहीं है? क्योंकि तुम एक करने के लिए एक निश्चित मूल्य की स्थापना शुरू करते हैं, तो घटाना है (या नहीं, सीमा पर निर्भर करता है, लेकिन हम ने कहा कि यह तय किया गया था) एक निश्चित राशि है, तो यह होना चाहिए ... 20.

ठीक है, अगर तुम

का मूल्यांकन

Example new testArraySum 

कई बार, आपको 20,18, 16 मिलेगा ... क्योंकि सरणी # (4 8 10) संशोधित हो जाती है। दूसरी ओर,

Example >> testConstantArraySum 
    | a | 
    a := Array new: 3. 
    a at: 1 put: 4; at: 2 put: 8; at: 3 put: 10. 
    a sum > threshold ifTrue: [ a at: 1 put: a first - 2 ]. 
    ^a sum 

वास्तव में स्थिर है।