अपरिवर्तनीय वस्तु

"दृढ़" and "अपरिवर्तनीयता" redirect here. For ईसाई सिद्धांत, see अपरिवर्तनीयता (धर्मशास्त्र). For the album, see अपरिवर्तनीय (एल्बम).

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

ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में पठनीयता और रनटाइम दक्षता में सुधार के लिए स्ट्रिंग्स और अन्य ठोस वस्तुओं को सामान्यतः अपरिवर्तनीय वस्तुओं के रूप में व्यक्त किया जाता है। अपरिवर्तनीय वस्तुएँ भी उपयोगी होती हैं क्योंकि वे स्वाभाविक रूप से थ्रेड सुरक्षा | थ्रेड-सुरक्षित होती हैं।अन्य लाभ यह हैं कि वे समझने में सरल हैं और उनके बारे में तर्क करते हैं और परिवर्तनशील वस्तुओं की तुलना में उच्च सुरक्षा प्रदान करते हैं।

अवधारणाएं

अपरिवर्तनीय चर

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

रीड-ओनली फ़ील्ड की गणना तब की जा सकती है जब प्रोग्राम चलता है (स्थिरांक के विपरीत, जो पहले से ज्ञात हैं), किन्तु आरंभ होने के बाद कभी नहीं बदलते।

कमजोर बनाम मजबूत अपरिवर्तनीयता

कभी-कभी, किसी वस्तु के कुछ क्षेत्रों के अपरिवर्तनीय होने की बात करता है। इसका अर्थ है कि वस्तु स्थिति के उन भागों को बदलने का कोई तरीका नहीं है, भले ही वस्तु के अन्य भाग परिवर्तनशील (कमजोर रूप से अपरिवर्तनीय) हो सकते हैं। यदि सभी क्षेत्र अपरिवर्तनीय हैं, तो वस्तु अपरिवर्तनीय है। यदि संपूर्ण वस्तु को किसी अन्य वर्ग द्वारा विस्तारित नहीं किया जा सकता है, तो वस्तु को दृढ़ता से अपरिवर्तनीय कहा जाता है। यह, उदाहरण के लिए, वस्तु के जीवनकाल के माध्यम से समान रहने वाली वस्तु में कुछ निश्चित डेटा के बारे में स्पष्ट रूप से लागू करने में मदद कर सकता है। कुछ भाषाओं में, यह कीवर्ड के साथ किया जाता है (उदा. const सी ++ में, final जावा (प्रोग्रामिंग भाषा) में) जो क्षेत्र को अपरिवर्तनीय के रूप में निर्दिष्ट करता है। कुछ भाषाएं इसे उलट देती हैं: OCaml में, किसी वस्तु या रिकॉर्ड के क्षेत्र डिफ़ॉल्ट रूप से अपरिवर्तनीय होते हैं, और इन्हें स्पष्ट रूप से चिह्नित किया जाना चाहिए mutable ऐसा होना।

वस्तुओं के संदर्भ

अधिकांश वस्तु-उन्मुख प्रोग्रामिंग भाषा |ऑब्जेक्ट-ओरिएंटेड लैंग्वेज में, ऑब्जेक्ट्स को रेफरेंस (कंप्यूटर साइंस) का उपयोग करके संदर्भित किया जा सकता है। ऐसी भाषाओं के कुछ उदाहरण जावा (प्रोग्रामिंग भाषा), सी++, सी शार्प (प्रोग्रामिंग भाषा)|सी#, वीबी.नेट और कई स्क्रिप्टिंग भाषाएं हैं, जैसे पर्ल, पायथन (प्रोग्रामिंग भाषा), और रूबी प्रोग्रामिंग भाषा। इस स्थिति में, यह मायने रखता है कि क्या किसी वस्तु की स्थिति भिन्न हो सकती है जब वस्तुओं को संदर्भों के माध्यम से साझा किया जाता है।

वस्तुओं की नकल बनाम संदर्भ

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

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

लिखने पर नकल

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

इंटर्निंग

समान वस्तुओं की प्रतियों के स्थान पर हमेशा संदर्भों का उपयोग करने की प्रथा को इंटर्न (कंप्यूटर विज्ञान) के रूप में जाना जाता है। यदि इंटर्निंग का उपयोग किया जाता है, तो दो वस्तुओं को समान माना जाता है यदि और केवल यदि उनके संदर्भ, सामान्यतः पॉइंटर्स या पूर्णांक के रूप में दर्शाए जाते हैं, बराबर होते हैं। कुछ भाषाएँ स्वचालित रूप से ऐसा करती हैं: उदाहरण के लिए, पायथन (प्रोग्रामिंग भाषा) स्वचालित रूप से स्ट्रिंग इंटर्न पूल। यदि एल्गोरिदम जो इंटर्निंग को लागू करता है, उसे हर स्थिति में ऐसा करने की गारंटी दी जाती है कि यह संभव है, तो समानता के लिए वस्तुओं की तुलना उनके पॉइंटर्स की तुलना करने के लिए कम हो जाती है - अधिकांश अनुप्रयोगों में गति में पर्याप्त लाभ। (यहां तक ​​​​कि अगर एल्गोरिदम व्यापक होने की गारंटी नहीं है, तब भी वस्तुओं के बराबर होने और समान संदर्भ का उपयोग करने पर तेज़ पथ स्थिति में सुधार की संभावना सम्मिलित है।) इंटर्निंग सामान्यतः केवल अपरिवर्तनीय वस्तुओं के लिए उपयोगी होती है।

थ्रेड सुरक्षा

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

अपरिवर्तनीयता का उल्लंघन

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

भाषा-विशिष्ट विवरण

पायथन (प्रोग्रामिंग लैंग्वेज), जावा (प्रोग्रामिंग लैंग्वेज) और .NET फ्रेमवर्क में, स्ट्रिंग्स अपरिवर्तनीय वस्तुएं हैं। जावा और .NET फ्रेमवर्क दोनों में स्ट्रिंग के परिवर्तनशील संस्करण हैं। जावा में ये हैं StringBuffer और StringBuilder (जावा के परिवर्तनशील संस्करण String) और .NET में यह है StringBuilder (.Net का परिवर्तनशील संस्करण String). पायथन 3 में परिवर्तनशील स्ट्रिंग (बाइट्स) संस्करण है, जिसका नाम है bytearray. इसके अतिरिक्त, जावा में सभी वर्चुअल आवरण वर्ग अपरिवर्तनीय हैं।

इसी तरह के पैटर्न अपरिवर्तनीय इंटरफ़ेस और अपरिवर्तनीय आवरण हैं।

शुद्ध कार्यात्मक प्रोग्रामिंग भाषाओं में भाषा को विस्तारित किए बिना परिवर्तनीय वस्तुओं को बनाना संभव नहीं है (उदाहरण के लिए परिवर्तनीय संदर्भ लाइब्रेरी या विदेशी फ़ंक्शन इंटरफ़ेस के माध्यम से), इसलिए सभी ऑब्जेक्ट अपरिवर्तनीय हैं।

एडीए

एडीए (प्रोग्रामिंग लैंग्वेज) में, किसी भी वस्तु को या तो चर घोषित किया जाता है (अर्थात परिवर्तनशील; सामान्यतः अंतर्निहित डिफ़ॉल्ट), या constant (अर्ताथ अपरिवर्तनीय) के माध्यम से constant कीवर्ड।

  type Some_type is new Integer; -- could be anything more complicated
  x: constant Some_type:= 1; -- immutable
  y: Some_type; -- mutable

उपप्रोग्राम पैरामीटर इन मोड में अपरिवर्तनीय हैं, और आउट और आउट मोड में उत्परिवर्तनीय हैं।

  procedure Do_it(a: in Integer; b: in out Integer; c: out Integer) is
  begin
    -- a is immutable
    b:= b + a;
    c:= a;
  end Do_it;

सी #

सी शार्प (प्रोग्रामिंग लैंग्वेज) | सी # में आप वर्ग के क्षेत्रों की अपरिवर्तनीयता को लागू कर सकते हैं readonly कथन। सभी क्षेत्रों को अपरिवर्तनीय के रूप में लागू करके, आप अपरिवर्तनीय प्रकार प्राप्त करते हैं।

class AnImmutableType
{
    public readonly double _value;
    public AnImmutableType(double x) 
    { 
        _value = x; 
    }
    public AnImmutableType Square() 
    { 
        return new AnImmutableType(_value * _value); 
    }
}

सी ++

सी ++ में, कॉन्स्ट-शुद्धता | कॉन्स्ट-सही कार्यान्वयन Cart उपयोगकर्ता को कक्षा के उदाहरण बनाने और फिर उनका उपयोग करने की अनुमति देगा const (अपरिवर्तनीय) या परिवर्तनशील, जैसा कि वांछित है, के दो अलग-अलग संस्करण प्रदान करके items() तरीका। (ध्यान दें कि सी ++ में यह जरूरी नहीं है - और वास्तव में असंभव - विशेष कन्स्ट्रक्टर प्रदान करने के लिए const उदाहरण।)

class Cart {
 public:
  Cart(std::vector<Item> items): items_(items) {}

  std::vector<Item>& items() { return items_; }
  const std::vector<Item>& items() const { return items_; }

  int ComputeTotalCost() const { /* return sum of the prices */ }

 private:
  std::vector<Item> items_;
};

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

C++ सार (बिटवाइज़ के विपरीत) के माध्यम से अपरिवर्तनीयता भी प्रदान करता है mutable कीवर्ड, जो सदस्य चर को के भीतर से बदलने देता है const तरीका।

class Cart {
 public:
  Cart(std::vector<Item> items): items_(items) {}

  const std::vector<Item>& items() const { return items_; }

  int ComputeTotalCost() const {
    if (total_cost_) {
      return *total_cost_;
    }

    int total_cost = 0;
    for (const auto& item : items_) {
      total_cost += item.Cost();
    }
    total_cost_ = total_cost;
    return total_cost;
  }

 private:
  std::vector<Item> items_;
  mutable std::optional<int> total_cost_;
};

डी

D (प्रोग्रामिंग लैंग्वेज) में, दो प्रकार क्वालीफायर टाइप करें सम्मिलित होते हैं, const और immutable, वेरिएबल्स के लिए जिन्हें बदला नहीं जा सकता। C++ के विपरीत const, मई आपको final, और सी#एस readonly, वे सकर्मक हैं और ऐसे चर के संदर्भों के माध्यम से किसी भी चीज़ पर पुनरावर्ती रूप से लागू होते हैं। बीच में अंतर const और immutable वे किस पर लागू होते हैं: const चर की संपत्ति है: संदर्भित मूल्य के लिए कानूनी रूप से परस्पर संदर्भ सम्मिलित हो सकते हैं, अर्थात मूल्य वास्तव में बदल सकता है। इसके विपरीत, immutable निर्दिष्ट मूल्य की संपत्ति है: मूल्य और इससे संक्रमणीय रूप से पहुंचने योग्य कुछ भी नहीं बदला जा सकता है (टाइप सिस्टम को तोड़ने के बिना, अपरिभाषित व्यवहार के लिए अग्रणी)। उस मान के किसी भी संदर्भ को चिह्नित किया जाना चाहिए const या immutable. मूल रूप से किसी भी अयोग्य प्रकार के लिए T, const(T) का असंयुक्त संघ है T (परिवर्तनीय) और immutable(T).

class C {
  /*mutable*/ Object mField;
    const     Object cField;
    immutable Object iField;
}

एक परिवर्तनशील के लिए C वस्तु, उसका mField को लिखा जा सकता है। के लिए const(C) वस्तु, mField संशोधित नहीं किया जा सकता, यह इनहेरिट करता है const; iField अभी भी अपरिवर्तनीय है क्योंकि यह मजबूत गारंटी है। के लिए immutable(C), सभी क्षेत्र अपरिवर्तनीय हैं।

इस तरह फंक्शन में:

void func(C m, const C c, immutable C i)
{ /* inside the braces */ }

ब्रेसिज़ के अंदर, c के रूप में ही वस्तु को संदर्भित कर सकता है m, इसलिए उत्परिवर्तन m परोक्ष रूप से बदल सकता है c भी। भी,

c के रूप में ही वस्तु को संदर्भित कर सकता है i, किन्तु चूंकि मूल्य अपरिवर्तनीय है, इसमें कोई बदलाव नहीं है। चूंकि, m और i कानूनी रूप से ही वस्तु का उल्लेख नहीं कर सकता।

गारंटी की भाषा में, mutable की कोई गारंटी नहीं है (फ़ंक्शन वस्तु को बदल सकता है), const केवल-बाहरी गारंटी है कि फ़ंक्शन कुछ भी नहीं बदलेगा, और

immutable द्विदिश गारंटी है (फ़ंक्शन मान नहीं बदलेगा और कॉल करने वाले को इसे नहीं बदलना चाहिए)।

मान जो हैं const या immutable घोषणा के बिंदु (कंप्यूटर प्रोग्रामिंग) या कंस्ट्रक्टर (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) द्वारा प्रत्यक्ष असाइनमेंट द्वारा आरंभ किया जाना चाहिए।

क्योंकि const पैरामीटर भूल जाते हैं कि मान उत्परिवर्तनीय था या नहीं, समान निर्माण, inout, कार्य करता है, अर्थ में, परिवर्तनीय जानकारी के लिए चर के रूप में। प्रकार का कार्य const(S) function(const(T)) रिटर्न const(S) उत्परिवर्तनीय, स्थिरांक और अपरिवर्तनीय तर्कों के लिए टाइप किए गए मान। इसके विपरीत, प्रकार का कार्य inout(S) function(inout(T)) रिटर्न S परिवर्तनशील के लिए T तर्क, const(S) के लिए const(T) मूल्य, और immutable(S) के लिए immutable(T) मान।

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

प्ररूप string के लिए उपनाम है immutable(char)[], अर्ताथ अपरिवर्तनीय पात्रों की स्मृति का टाइप किया हुआ टुकड़ा। सबस्ट्रिंग बनाना सस्ता है, क्योंकि यह सिर्फ पॉइंटर और फाइल की गई लंबाई को कॉपी और संशोधित करता है, और सुरक्षित है, क्योंकि अंतर्निहित डेटा को बदला नहीं जा सकता है। प्रकार की वस्तुएँ const(char)[] स्ट्रिंग्स को संदर्भित कर सकता है, किन्तु म्यूटेबल बफ़र्स को भी।

किसी स्थिरांक या अपरिवर्तनीय मान की उथली प्रतिलिपि बनाने से अपरिवर्तनीयता की बाहरी परत हट जाती है: अपरिवर्तनीय स्ट्रिंग की प्रतिलिपि बनाना (immutable(char[])) स्ट्रिंग देता है (immutable(char)[]). अपरिवर्तनीय सूचक और लंबाई की नकल की जा रही है और प्रतियां परस्पर हैं। संदर्भित डेटा को कॉपी नहीं किया गया है और इसके क्वालीफायर को उदाहरण में रखा गया है immutable. गहरी प्रति बनाकर इसे हटाया जा सकता है, उदा। का उपयोग dup फंक्शन।

जावा

एक अपरिवर्तनीय वस्तु का उत्कृष्ट उदाहरण जावा का उदाहरण है String कक्षा

String s = "ABC";
s.toLowerCase();

प्रक्रिया toLowerCase() डेटा एबीसी कि नहीं बदलता है s रोकना। इसके अतिरिक्त, नया स्ट्रिंग ऑब्जेक्ट तत्काल किया जाता है और इसके निर्माण के दौरान डेटा एबीसी दिया जाता है। इस स्ट्रिंग ऑब्जेक्ट का संदर्भ इसके द्वारा दिया जाता है toLowerCase() तरीका। स्ट्रिंग बनाने के लिए s डेटा सम्मिलित करें abc , अलग दृष्टिकोण की आवश्यकता है:

s = s.toLowerCase();

अब स्ट्रिंग s नई स्ट्रिंग ऑब्जेक्ट का संदर्भ देता है जिसमें abc सम्मिलित है। वर्ग स्ट्रिंग की घोषणा के सिंटैक्स में कुछ भी नहीं है जो इसे अपरिवर्तनीय के रूप में लागू करता है; बल्कि, स्ट्रिंग क्लास की कोई भी विधि उस डेटा को प्रभावित नहीं करती है जिसमें स्ट्रिंग ऑब्जेक्ट सम्मिलित है, इस प्रकार इसे अपरिवर्तनीय बना देता है।

कीवर्ड final (अंतिम (जावा)#अंतिम चर) का उपयोग अपरिवर्तनीय वर्चुअल प्रकार और वस्तु संदर्भों को लागू करने में किया जाता है, किन्तु यह स्वयं वस्तुओं को अपरिवर्तनीय नहीं बना सकता है। नीचे उदाहरण देखें:

वर्चुअल प्रकार चर (int, long, short, आदि) परिभाषित होने के बाद पुन: असाइन किया जा सकता है। के प्रयोग से इससे बचा जा सकता है final.

int i = 42; //int is a primitive type
i = 43; // OK

final int j = 42;
j = 43; // does not compile. j is final so can't be reassigned

केवल का उपयोग करके संदर्भ प्रकारों को अपरिवर्तनीय नहीं बनाया जा सकता है final कीवर्ड। final केवल पुन: असाइनमेंट रोकता है।

final MyObject m = new MyObject(); //m is of reference type
m.data = 100; // OK. We can change state of object m (m is mutable and final doesn't change this fact)
m = new MyObject(); // does not compile. m is final so can't be reassigned

वर्चुअल रैपर (Integer, Long, Short, Double, Float, Character, Byte, Boolean) भी सभी अपरिवर्तनीय हैं। कुछ सरल दिशानिर्देशों का पालन करके अपरिवर्तनीय कक्षाएं लागू की जा सकती हैं।

जावास्क्रिप्ट

जावास्क्रिप्ट में, सभी वर्चुअल प्रकार (अपरिभाषित, अशक्त, बूलियन, संख्या, BigInt, स्ट्रिंग, प्रतीक) अपरिवर्तनीय हैं, किन्तु कस्टम ऑब्जेक्ट सामान्यतः परिवर्तनशील होते हैं।

function doSomething(x) { /* does changing x here change the original? */ };
var str = 'a string';
var obj = { an: 'object' };
doSomething(str);         // strings, numbers and bool types are immutable, function gets a copy
doSomething(obj);         // objects are passed in by reference and are mutable inside function
doAnotherThing(str, obj); // `str` has not changed, but `obj` may have.

किसी वस्तु में अपरिवर्तनीयता का अनुकरण करने के लिए, गुणों को केवल-पढ़ने के लिए परिभाषित किया जा सकता है (लिखने योग्य: झूठा)।

var obj = {};
Object.defineProperty(obj, 'foo', { value: 'bar', writable: false });
obj.foo = 'bar2'; // silently ignored

चूंकि, उपरोक्त दृष्टिकोण अभी भी नई संपत्तियों को जोड़ने देता है। वैकल्पिक रूप से, कोई सम्मिलिता वस्तुओं को अपरिवर्तनीय बनाने के लिए Object.freeze का उपयोग कर सकता है।

var obj = { foo: 'bar' };
Object.freeze(obj);
obj.foo = 'bars'; // cannot edit property, silently ignored
obj.foo2 = 'bar2'; // cannot add property, silently ignored

ECMA262 के कार्यान्वयन के साथ, जावास्क्रिप्ट में अपरिवर्तनीय संदर्भ बनाने की क्षमता है जिसे पुन: असाइन नहीं किया जा सकता है। चूंकि, ए का उपयोग करना const घोषणा का अर्थ यह नहीं है कि रीड-ओनली रेफरेंस का मूल्य अपरिवर्तनीय है, बस नाम को नए मान को नहीं सौंपा जा सकता है।

const ALWAYS_IMMUTABLE = true;

try {
  ALWAYS_IMMUTABLE = false;
} catch (err) {
  console.log("Can't reassign an immutable reference.");
}

const arr = [1, 2, 3];
arr.push(4);
console.log(arr); // [1, 2, 3, 4]

प्रतिक्रिया (जावास्क्रिप्ट लाइब्रेरी) की प्रारंभ के बाद से जावास्क्रिप्ट में अपरिवर्तनीय स्थिति का उपयोग बढ़ती प्रवृत्ति बन गया है, जो फ्लक्स-जैसे राज्य प्रबंधन पैटर्न जैसे रेडक्स (जावास्क्रिप्ट लाइब्रेरी) का समर्थन करता है।

पर्ल

पर्ल में, केवल सभी विशेषताओं को केवल पढ़ने के लिए घोषित करके मू लाइब्रेरी के साथ अपरिवर्तनीय वर्ग बना सकते हैं:

package Immutable;
use Moo;

has value => (
    is      => 'ro',   # read only
    default => 'data', # can be overridden by supplying the constructor with
                       # a value: Immutable->new(value => 'something else');
);

1;

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

package Immutable;
use strict;
use warnings;
use base qw(Class::Accessor);
# create read-only accessors
__PACKAGE__->mk_ro_accessors(qw(value));
use Hash::Util 'lock_hash';

sub new {
    my $class = shift;
    return $class if ref($class);
    die "Arguments to new must be key => value pairs\n"
        unless (@_ % 2 == 0);
    my %defaults = (
        value => 'data',
    );
    my $obj = {
        %defaults,
        @_,
    };
    bless $obj, $class;
    # prevent modification of the object data
    lock_hash %$obj;
}
1;

या, मैन्युअल रूप से लिखे गए एक्सेसर के साथ:

package Immutable;
use strict;
use warnings;
use Hash::Util 'lock_hash';

sub new {
    my $class = shift;
    return $class if ref($class);
    die "Arguments to new must be key => value pairs\n"
        unless (@_ % 2 == 0);
    my %defaults = (
        value => 'data',
    );
    my $obj = {
        %defaults,
        @_,
    };
    bless $obj, $class;
    # prevent modification of the object data
    lock_hash %$obj;
}

# read-only accessor
sub value {
    my $self = shift;
    if (my $new_value = shift) {
        # trying to set a new value
        die "This object cannot be modified\n";
    } else {
        return $self->{value}
    }
}
1;

पायथन

पायथन (प्रोग्रामिंग लैंग्वेज) में, कुछ बिल्ट-इन प्रकार (संख्या, बूलियन, स्ट्रिंग्स, टुपल्स, फ्रोजनसेट) अपरिवर्तनीय हैं, किन्तु कस्टम वर्ग सामान्यतः परिवर्तनशील होते हैं। वर्ग में अपरिवर्तनीयता का अनुकरण करने के लिए, अपवाद बढ़ाने के लिए विशेषता सेटिंग और विलोपन को ओवरराइड कर सकता है:

class ImmutablePoint:
    """An immutable class with two attributes 'x' and 'y'."""

    __slots__ = ['x', 'y']

    def __setattr__(self, *args):
        raise TypeError("Can not modify immutable instance.")

    __delattr__ = __setattr__

    def __init__(self, x, y):
        # We can no longer use self.value = value to store the instance data
        # so we must explicitly call the superclass
        super().__setattr__('x', x)
        super().__setattr__('y', y)

मानक लाइब्रेरी सहायक collections.namedtuple और typing.NamedTuple, पायथन 3.6 से आगे उपलब्ध, सरल अपरिवर्तनीय कक्षाएं बनाएं। निम्नलिखित उदाहरण मोटे तौर पर ऊपर के बराबर है, साथ ही कुछ टपल जैसी विशेषताएं हैं:

from typing import NamedTuple
import collections

Point = collections.namedtuple('Point', ['x', 'y'])

# the following creates a similar namedtuple to the above
class Point(NamedTuple):
    x: int
    y: int

पायथन 3.7 में पेश किया गया, dataclasses डेवलपर्स को फ्रोजन इंस्टेंसेस के साथ अपरिवर्तनीयता का अनुकरण करने की अनुमति दें। यदि जमे हुए डेटाक्लास का निर्माण किया जाता है, dataclasses ओवरराइड करेगा __setattr__() और __delattr__() अप करने के लिए FrozenInstanceError अगर आह्वान किया गया।

from dataclasses import dataclass

@dataclass(frozen=True)
class Point:
    x: int
    y: int

रैकेट

रैकेट (प्रोग्रामिंग भाषा) अपने कोर पेयर टाइप (cons cells) को अपरिवर्तनीय बनाकर अन्य स्कीम (प्रोग्रामिंग लैंग्वेज) के कार्यान्वयन से काफी हद तक अलग हो जाता है। इसके अतिरिक्त, यह समानांतर परिवर्तनशील जोड़ी प्रकार प्रदान करता है mcons, mcar, set-mcar! आदि। इसके अतिरिक्त, कई अपरिवर्तनीय प्रकारों का समर्थन किया जाता है, उदाहरण के लिए, अपरिवर्तनीय तार और वैक्टर, और इनका बड़े पैमाने पर उपयोग किया जाता है। नई संरचनाएं डिफ़ॉल्ट रूप से अपरिवर्तनीय होती हैं, जब तक कि किसी फ़ील्ड को विशेष रूप से परिवर्तनशील घोषित नहीं किया जाता है, या संपूर्ण संरचना:

(struct foo1 (x y))             ; all fields immutable
(struct foo2 (x [y #:mutable])) ; one mutable field
(struct foo3 (x y) #:mutable)   ; all fields mutable

भाषा अपरिवर्तनीय हैश टेबल, कार्यात्मक रूप से कार्यान्वित और अपरिवर्तनीय शब्दकोशों का भी समर्थन करती है।

जंग

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

लगातार आइटम जंग में हमेशा अपरिवर्तनीय होते हैं।

// constant items are always immutable
const ALWAYS_IMMUTABLE: bool = true;

struct Object {
    x: usize,
    y: usize,
}

fn main() {
    // explicitly declare a mutable variable
    let mut mutable_obj = Object { x: 1, y: 2 };
    mutable_obj.x = 3; // okay

    let mutable_ref = &mut mutable_obj;
    mutable_ref.x = 1; // okay

    let immutable_ref = &mutable_obj;
    immutable_ref.x = 3; // error E0594

    // by default, variables are immutable
    let immutable_obj = Object { x: 4, y: 5 };
    immutable_obj.x = 6; // error E0596

    let mutable_ref2 = 
        &mut immutable_obj; // error E0596

    let immutable_ref2 = &immutable_obj;
    immutable_ref2.x = 6; // error E0594
    
}

स्कैला

स्काला (प्रोग्रामिंग भाषा) में, किसी भी इकाई (संक्षिप्त रूप से, बाध्यकारी) को उत्परिवर्तनीय या अपरिवर्तनीय के रूप में परिभाषित किया जा सकता है: घोषणा में, कोई भी उपयोग कर सकता है val (मान) अपरिवर्तनीय संस्थाओं के लिए और var (चर) परिवर्तनशील लोगों के लिए। ध्यान दें कि भले ही अपरिवर्तनीय बंधन को पुन: असाइन नहीं किया जा सकता है, फिर भी यह परिवर्तनीय वस्तु को संदर्भित कर सकता है और उस वस्तु पर उत्परिवर्तन विधियों को कॉल करना अभी भी संभव है: बाध्यकारी अपरिवर्तनीय है, किन्तु अंतर्निहित वस्तु उत्परिवर्तनीय हो सकती है।

उदाहरण के लिए, निम्नलिखित कोड स्निपेट:

val maxValue = 100
var currentValue = 1

एक अपरिवर्तनीय इकाई को परिभाषित करता है maxValue (पूर्णांक प्रकार संकलन-समय पर अनुमानित है) और उत्परिवर्तनीय इकाई नामित है currentValue.

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

यह भी देखें

• क्लोजर
• एरलांग (प्रोग्रामिंग भाषा)
• एफ शार्प (प्रोग्रामिंग भाषा)|एफ#
• हास्केल (प्रोग्रामिंग भाषा)
• म्यूटेटर विधि
• प्रोलॉग
• स्काला (प्रोग्रामिंग भाषा)
• टीसीएल

संदर्भ

This article contains some material from the Perl Design Patterns Book

बाहरी संबंध

• Immutable objects in C# using 3 simple steps.
• Article Java theory and practice: To mutate or not to mutate? by Brian Goetz, from IBM DeveloperWorks – saved copy at Internet Archive by Brian Goetz, from IBM DeveloperWorks – saved copy at Internet Archive
• Immutable objects from JavaPractices.com
• Immutable objects from Portland Pattern Repository
• Immutable.js by Facebook
• Immutable structures in C# Archived 2017-12-21 at the Wayback Machine opensource project in Codeplex
• Immutable collections in .NET official library by Microsoft
• Immutable objects in C# by Tutlane.com