Dart में '' const 'और' 'final' 'कीवर्ड के बीच अंतर क्या है?




keyword (5)

Dart में const और final कीवर्ड के बीच अंतर क्या है?

https://code.i-harness.com


कॉन्स्ट

मूल्य को संकलन-समय पर जाना चाहिए, const birth = "2008/12/26" समय const birth = "2008/12/26" । प्रारंभ के बाद बदला नहीं जा सकता

अंतिम

मूल्य रन-टाइम , final birth = getBirthFromDB() पर जाना चाहिए। प्रारंभ के बाद बदला नहीं जा सकता


@Meyi द्वारा उत्तर का विस्तार

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

  • वर्गों से परिवर्तनीय अंतिम हो सकता है लेकिन स्थिर नहीं है और यदि आप कक्षा स्तर पर एक स्थिर चाहते हैं तो इसे स्थिर गति प्रदान करें।

कोड:

void main() {

    // final demonstration
    final biggestNumberOndice = '6';
    //  biggestNumberOndice = '8';     // Throws an error for reinitialization

    // const
    const smallestNumberOnDice = 1;

}

class TestClass {

    final biggestNumberOndice = '6';

    //const smallestNumberOnDice = 1;  //Throws an error
    //Error .  only static fields can be declared as constants.

    static const smallestNumberOnDice = 1;
}

यदि आप C++ से आ रहे हैं तो Dart में const , C++ में constexpr C++ और Dart में final , C++ में const C++

उपरोक्त केवल आदिम प्रकारों पर लागू होता है। हालांकि Dart वस्तुओं में final रूप से यह सदस्यों के संदर्भ में परस्पर हैं।


समेकित @Meyi और @ faisal-naseer उत्तर और छोटी प्रोग्रामिंग के साथ तुलना।

स्थिरांक:

const कीवर्ड का उपयोग कंपाइल समय स्थिर मान को संचय करने के लिए किया जाता है। संकलित समय निरंतर मान एक मूल्य है जो संकलित करते समय निरंतर होगा :-)

उदाहरण के लिए 5 एक संकलन समय स्थिर है। जबकि DateTime.now() जो समय स्थिर नहीं है। क्योंकि यह विधि उस समय वापस आ जाएगी जब लाइन रनटाइम पर निष्पादित हो रही हो। इसलिए हम एक const वेरिएबल को DateTime.now() असाइन नहीं कर सकते हैं।

const a = 5;
// Uncommenting below statement will cause compile time error.
// Because we can't able to assign a runtime value to a const variable
// const b = DateTime.now();

एक ही लाइन पर आरंभीकृत किया जाना चाहिए।

const a = 5;
// Uncommenting below 2 statement will cause compilation error.
// Because const variable must be initialized at the same line.
// const b;
// b = 6;

नीचे उल्लिखित सभी कथन स्वीकार्य हैं।

// Without type or var
const a = 5;
// With a type
const int b = 5;
// With var
const var c = 6;

क्लास लेवल कास्ट वैरिएबल को नीचे की तरह इनिशियलाइज़ किया जाना चाहिए।

Class A {
    static const a = 5;
}

इंस्टेंस लेवल कॉन्स्टेबल वेरिएबल संभव नहीं है

Class A {
    // Uncommenting below statement will give compilation error.
    // Because const is not possible to be used with instance level 
    // variable.
    // const a = 5;
}

const का एक अन्य प्रमुख उपयोग वस्तु को अपरिवर्तनीय बनाने के लिए किया जाता है। क्लास ऑब्जेक्ट को अपरिवर्तनीय बनाने के लिए हमें कंस्ट्रक्टर के साथ कॉन्स्टेबल कीवर्ड का उपयोग करना होगा और सभी फ़ील्ड्स को अंतिम रूप में नीचे बताए अनुसार बनाना होगा।

Class A {
    final a, b;
    const A(this.a, this.b);
}

void main () {
    // There is no way to change a field of object once it's 
    // initialized.
    const immutableObja = const A(5, 6);
    // Uncommenting below statement will give compilation error.
    // Because you are trying to reinitialize a const variable
    // with other value
    // immutableObja = const A(7, 9);

    // But the below one is not the same. Because we are mentioning objA 
    // is a variable of a class A. Not const. So we can able to assign
    // another object of class A to objA.
    A objA = const A(8, 9);
    // Below statement is acceptable.
    objA = const A(10, 11);
}

हम एक सूची में कॉन्स्टेबल कीवर्ड का उपयोग कर सकते हैं।

const a = const [] - एक वैरिएबल जिसे const रूप में इनिशियलाइज़ किया गया है जिसमें const ऑब्जेक्ट्स की एक सूची है (यानी, लिस्ट में केवल कंपाइल टाइम कंटीन्यूअस और अपरिवर्तनीय ऑब्जेक्ट्स होने चाहिए)। इसलिए हम दूसरी सूची के साथ असाइन नहीं कर सकते

var a = const [] - एक वैरिएबल a वैरिएबल के रूप में इनिशियलाइज़ किया जाता है, जिसमें एक लिस्ट const ऑब्जेक्ट्स होते हैं । इसलिए हम वैरिएबल को दूसरी लिस्ट सौंप सकते हैं

Class A {
    final a, b;
    const A(this.a, this.b);
}

class B {
    B(){ // Doing something }
}

void main() {
    const constantListOfInt = const [5, 6, 7,
                 // Uncommenting below statement give compilation error.
                 // Because we are trying to add a runtime value
                 // to a constant list
                 // DateTime.now().millisecondsSinceEpoch
              ];
    const constantListOfConstantObjA = const [
        A(5, 6),
        A(55, 88),
        A(100, 9),
    ];
    // Uncommenting below 2 statements will give compilation error.
    // Because we are trying to reinitialize with a new list.
    // constantListOfInt = [8, 9, 10];
    // constantListOfConstantObjA = const[A(55, 77)];

    // But the following lines are little different. Because we are just
    // trying to assign a list of constant values to a variable. Which 
    // is acceptable
    var variableWithConstantList = const [5, 6, 7];
    variableWithConstantList = const [10, 11, 15];
    var variableOfConstantListOfObjA = const [A(5, 8), A(7, 9), A(10, 4)];
    variableWithConstantList = const [A(9, 10)];
}

अंतिम:

अंतिम कीवर्ड का उपयोग चर को स्थिर मान रखने के लिए भी किया जाता है। एक बार आरंभ करने के बाद हम मूल्य को बदलने में सक्षम नहीं हो सकते।

final a = 5;
// Uncommenting below statement will give compilation error.
// Because a is declared as final.
// a = 6;

नीचे उल्लिखित सभी कथन स्वीकार्य हैं।

// Without type or var
final a = 5;
// With a type
final int b = 5;
// With var
final var c = 6;

रनटाइम मान असाइन करने में सक्षम हो सकता है।

// DateTime.now() will return the time when the line is getting
// executed. Which is a runtime value.
final a = DateTime.now();
var b = 5;
final c = b;

कक्षा स्तर के अंतिम चर को एक ही पंक्ति में आरंभीकृत किया जाना चाहिए।

Class A {
    static final a = 5;
    static final b = DateTime.now();
}

इंस्टेंस लेवल फाइनल वैरिएबल को एक ही लाइन या कंस्ट्रक्टर इनिशियलाइज़ेशन में आरंभीकृत किया जाना चाहिए। जब ऑब्जेक्ट बनाया जाता है तो मूल्य को मेमोरी में डाल दिया जाएगा।

Class A {
    final a = 5;
}

// Constructor with a parameter.
Class B {
    final b;
    B(this.b);
}

// Constructor with multiple parameter.
Class C {
    final c;
    C(this.c, int d) {
        // Do something with d
    }
}

void main() {
    A objA = new A();
    B objB = new B(5);
    C objC = new C(5, 6);
}

एक सूची सौंपना।

final a = [5, 6, 7, 5.6, A()];
// Uncommenting Below statement will give compilation error.
// Because we are trying to reinitialize the object with another list.
// a = [9.9, 10, B()];

डार्ट की वेबसाइट पर एक पोस्ट है और यह इसे बहुत अच्छी तरह से समझाता है।

अंतिम:

"फाइनल" का अर्थ एकल असाइनमेंट है: एक अंतिम चर या क्षेत्र में एक इनिशलाइज़र होना चाहिए । एक बार एक मान निर्दिष्ट करने के बाद, एक अंतिम चर का मूल्य नहीं बदला जा सकता है। अंतिम चर को संशोधित करता है

कॉन्स्ट:

"const" का अर्थ है कि डार्ट में थोड़ा अधिक जटिल और सूक्ष्म। const मानों को संशोधित करता है । आप इसका उपयोग संग्रह बनाते समय कर सकते हैं, जैसे const [1, 2, 3], और जब const (2 के रूप में) नए ऑब्जेक्ट्स का निर्माण करते हैं (2, 3)। यहां, कॉन्स्ट का मतलब है कि वस्तु की संपूर्ण गहरी स्थिति को पूरी तरह से संकलन के समय पर निर्धारित किया जा सकता है और यह कि ऑब्जेक्ट जमे हुए और पूरी तरह से अपरिवर्तनीय होगा।

कास्ट ऑब्जेक्ट्स में कुछ दिलचस्प गुण और प्रतिबंध हैं:

उन्हें उस डेटा से बनाया जाना चाहिए, जिसकी गणना संकलन समय पर की जा सकती है। एक कास्ट ऑब्जेक्ट में रनटाइम पर गणना करने के लिए आपके पास किसी भी चीज की पहुंच नहीं होती है। 1 + 2 एक वैध कास्ट एक्सप्रेशन है, लेकिन नया DateTime.now () नहीं है।

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

वे विहित हैं । यह स्ट्रिंग इंटर्निंग की तरह है: किसी भी दिए गए कॉस्ट वैल्यू के लिए, एक सिंगल कास्ट ऑब्जेक्ट बनाया जाएगा और फिर से उपयोग नहीं किया जाएगा कि कितनी बार कॉन्स्टेंस एक्सप्रेशन का मूल्यांकन किया जाता है।

अच्छा तो इसका क्या मतलब है?

कॉन्स्ट:
यदि मान आपके पास है, तो रनटाइम ( new DateTime.now() , उदाहरण के लिए) पर गणना की जाती है, तो आप इसके लिए एक कास्ट का उपयोग नहीं कर सकते हैं । हालाँकि, यदि मान संकलन समय पर जाना जाता है ( const a = 1; ), तो आपको final उपयोग करना चाहिए। const और final बीच 2 अन्य बड़े अंतर हैं। सबसे पहले, यदि आप const का उपयोग कर रहे हैं, तो आपको इसे केवल const बजाय static const रूप में घोषित करना होगा। दूसरी बात, यदि आपके पास एक const कलेक्शन है, तो उसके अंदर सब कुछ const । यदि आपके पास final संग्रह है, तो उसके अंदर सब कुछ final नहीं है

अंतिम:
यदि आप संकलन समय पर मूल्य नहीं जानते हैं, तो final का उपयोग const पर किया जाना चाहिए, और यह रनटाइम पर गणना / पकड़ा जाएगा। यदि आप एक HTTP प्रतिक्रिया चाहते हैं जिसे बदला नहीं जा सकता है, यदि आप डेटाबेस से कुछ प्राप्त करना चाहते हैं, या यदि आप किसी स्थानीय फ़ाइल से पढ़ना चाहते हैं, तो final उपयोग करें। कुछ भी जो संकलन के समय में ज्ञात नहीं है, उसे कब्ज पर final होना चाहिए।

कहा जा रहा है कि सभी के साथ, const और final दोनों को फिर से असाइन नहीं किया जा सकता है, लेकिन final ऑब्जेक्ट में फ़ील्ड, जब तक कि वे const या final नहीं होते हैं, तब तक फिर से डिज़ाइन किया जा सकता है ( const विपरीत)।





final