What is the Difference Between the const and final keywords In Dart?

· 10 min read
What is the Difference Between the “const” and “final” keywords In Dart
What is the Difference Between the “const” and “final” keywords In Dart

final means single-assignment: a final variable or field must have an initializer. Once assigned a value, a final variable’s value cannot be changed. final modifies variables so in this article, we will go through  What is the Difference Between the “const” and “final” keywords In Dart?

What is the Difference Between the “const” and “final” keywords In Dart?

The difference has to do with how memory is allocated. Memory is allocated for a final variable at runtime, and for a const variable at compile-time. The final modifier should be the more commonly used, because many program variables won’t need any memory since the program logic won’t call for them to be initialized.

With a const variable, you are basically telling the computer, “Hey, I need memory for this variable upfront because I know I’m going to need it.”

Const:

“const” has a meaning that’s a bit more complex and subtle in Dart. const modifies values. You can use it when creating collections, like const [1, 2, 3], and when constructing objects (instead of new) like const Point(2, 3). Here, const means that the object’s entire deep state can be determined entirely at compile-time and that the object will be frozen and completely immutable.

Const objects have a couple of interesting properties and restrictions:

They must be created from data that can be calculated at compile time. A const object does not have access to anything you would need to calculate at runtime. 1 + 2 is a valid const expression, but new DateTime.now() is not.

They are deeply, transitively immutable. If you have a final field containing a collection, that collection can still be mutable. If you have a const collection, everything in it must also be const, recursively.

They are canonicalized. This is sort of like string interning: for any given const value, a single const object will be created and re-used no matter how many times the const expression is evaluated.

  • a final variable can only be set once and it is initialized when accessed. for example from the code section below if you use the value of biggestNumberOndice only then the value will be initialized and memory will be assigned.
  • const is internally final in nature but the main difference is that its compile-time constant which is initialized during compilation even if you don’t use its value it will get initialized and will take space in memory.
  • Variable from classes can be final but not constant and if you want a constant at class level make it static const.

Code Snippet will look like the below:

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;
}

const:

const keyword used to make a variable to store a compile-time constant value. Compile-time constant value is a value that will be constant while compiling.

For example, 5 is a compile-time constant. While DateTime.now() which is not compile-time constant. Because this method will return the time when the line is getting executed at runtime. So we can’t assign the DateTime.now() to a const variable.

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();

Should be initialized at the same line.

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;

All statements mentioned below are acceptable.

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

Class level const variable should be initialized like below.

Class A {
    static const a = 5;
}

Instance level const variable is not possible.

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

Another major use of const is used to make the object immutable. To make a class object immutable we need to use the const keyword with a constructor and make all the fields as final like mentioned below.

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);
}

We can use a const keyword to a list.

const a = const [] – A variable initialized as const which contains a list of const objects(i.e., The list should contain only compile-time constant and immutable objects). So we can’t able to assign a with another list.

var a = const [] – A variable a initialized as var which contains a list const objects. so we can able to assign another list to the variable a.

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:

final keyword also used to make the variable hold a constant value. Once initialized we can’t able to change the value.

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

All statements mentioned below are acceptable.

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

Can able to assign a runtime value.

// 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;

The class level final variable must be initialized in the same line.

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

Instance level final variable must be initialized in the same line or in the constructor initialization. The value will be put into memory when the object is created.

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);
}

Assigning a list

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()];

Conclusion:

Thanks for reading !!!

In this article, we have been through what is the difference between the const and final keywords in Dart?

Keep Learning !!! Keep Fluttering !!!

FlutterAgency.com is our portal Platform dedicated to Flutter Technology and Flutter Developers. The portal is full of cool resources from Flutter like Flutter Widget GuideFlutter ProjectsCode libs and etc.

FlutterAgency.com is one of the most popular online portals dedicated to Flutter Technology and daily thousands of unique visitors come to this portal to enhance their knowledge of Flutter.

Leave a Reply