Quelle est la différence entre les mots-clés "const" et "final" dans Dart ?

Question

Quelle est la différence entre const et final mot-clé en Dart ?

Answer 1

Il y a un article sur le site de Dart qui l'explique assez bien.

Finale :

"final" signifie à affectation unique : une variable ou un champ final doit ont un initialisateur. Une fois qu'une valeur lui est attribuée, la valeur d'une variable finale ne peut pas être modifiée. final modifie variables .

---

Const :

Le terme "const" a une signification un peu plus complexe et subtile dans Dart. const modifie valeurs . Vous pouvez l'utiliser pour créer des collections, comme const [1, 2, 3], et pour construire des objets (au lieu de new) comme const Point(2, 3). Ici, const signifie que l'état profond de l'objet peut être entièrement déterminé au moment de la compilation et que l'objet sera gelé et complètement immuable.

Les objets Const ont quelques propriétés et restrictions intéressantes :

Ils doivent être créés à partir de données qui peuvent être calculées au moment de la compilation. Un objet const n'a pas accès à ce que vous auriez besoin de calculer au moment de l'exécution. 1 + 2 est une expression const valide, mais new DateTime.now() ne l'est pas.

Ils sont profondément, transitivement immuables. Si vous avez un champ final contenant une collection, cette collection peut toujours être mutable. Si vous avez une collection const, tout ce qu'elle contient doit également être const, de manière récursive.

Ils sont canonisé . C'est un peu comme l'internage de chaînes de caractères : pour une valeur const donnée, un seul objet const sera créé et réutilisé, quel que soit le nombre de fois où l'expression ou les expressions const sont évaluées.

---

Alors, qu'est-ce que cela signifie ?

Const :
Si la valeur que vous avez est calculée au moment de l'exécution ( new DateTime.now() par exemple), vous pouvez pas utiliser un const pour cela. Cependant, si la valeur est connue au moment de la compilation ( const a = 1; ), vous devez alors utiliser const sur final . Il existe deux autres grandes différences entre const et final . Tout d'abord, si vous utilisez const vous devez le déclarer comme static const plutôt que juste const . Deuxièmement, si vous avez un const tout ce qui est à l'intérieur de cette collection est dans const . Si vous avez un final tout ce qui est à l'intérieur de cette collection est pas final .

Finale :
final devrait être utilisé plutôt que const si vous ne connaissez pas la valeur au moment de la compilation, et elle sera calculée/grignotée au moment de l'exécution. Si vous voulez une réponse HTTP qui ne peut pas être modifiée, si vous voulez obtenir quelque chose à partir d'une base de données, ou si vous voulez lire à partir d'un fichier local, utilisez final . Tout ce qui n'est pas connu au moment de la compilation doit être final sur const .

---

Tout cela étant dit, les deux const et final ne peuvent pas être réaffectés, mais les champs d'un final tant qu'ils ne sont pas const ou final eux-mêmes, peuvent être réaffectés (contrairement aux const ).

Answer 2

Const.

La valeur doit être connue à temps de compilation , const birthday = "2008/12/25"
Ne peut pas être modifié après avoir été initialisé.

---

Final

La valeur doit être connue à temps d'exécution , final birthday = getBirthDateFromDB()
Ne peut pas être modifié après avoir été initialisé.

Answer 3

Consolidation des réponses de @Meyi et @faisal-naseer et comparaison avec une petite programmation.

const :

Le mot-clé const est utilisé pour créer une variable permettant de stocker un valeur constante au moment de la compilation . Une valeur constante à la compilation est une valeur qui sera constante pendant la compilation :-)

Par exemple 5 est une constante de temps de compilation. Alors que DateTime.now() qui n'est pas constant au moment de la compilation. Parce que cette méthode renvoie le le moment où la ligne est exécutée au moment de l'exécution. Nous ne pouvons donc pas affecter le DateTime.now() à un 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();

Devrait être initialisés à la même ligne .

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;

Toutes les déclarations mentionnées ci-dessous sont acceptables.

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

Variable constante de niveau classe doit être initialisé comme ci-dessous.

Class A {
    static const a = 5;
}

La variable const au niveau de l'instance n'est pas 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;
}

L'autre utilisation majeure de const est utilisé pour rendre le objet immuable . Pour rendre un objet de classe immuable, nous devons utiliser le mot clé const avec le constructeur et faire tous les champs comme finaux comme indiqué ci-dessous.

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

nous pouvons utiliser mot clé const à une liste .

const a = const [] - Une variable A a initialisé comme const qui contient une liste de const objets (c'est-à-dire que la liste ne doit contenir que des objets constants et immuables au moment de la compilation). Ainsi, nous ne sommes pas en mesure d'assigner a avec une autre liste .

var a = const [] - Une variable a initialisé comme var qui contient une liste const objets . Donc nous pouvons assigner une autre liste à la 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)];
}

---

finale :

Le mot clé final est également utilisé pour rendre la variable à maintenir une valeur constante . Une fois initialisé, nous ne pouvons pas changer la valeur.

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

Toutes les déclarations mentionnées ci-dessous sont acceptables.

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

Peut capable de attribuer une valeur d'exécution .

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

Variable finale de niveau classe doivent être initialisés dans la même ligne.

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

Variable finale au niveau de l'instance doivent être initialisés dans la même ligne ou dans l'initialisation du constructeur. La valeur sera mise en mémoire lors de la création de l'objet.

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

Attribution de une liste .

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

Answer 4

Extension de la réponse de @Meyi

• variable finale ne peut être définie qu'une seule fois et elle est initialisée lors de (par exemple, dans la section de code ci-dessous, si vous utilisez la valeur de biggestNumberOndice seulement alors la valeur sera initialisée et la mémoire sera assignée).

• const est de nature finale en interne mais la principale différence est que c'est une constante de compilation qui est initialisée lors de la compilation. même si vous n'utilisez pas sa valeur, elle sera initialisée et occupera de l'espace place en mémoire.

• Les variables des classes peuvent être finales mais pas constantes. constante au niveau de la classe, il faut la rendre static const.

Code :

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

Answer 5

Les deux sites final et const empêcher une variable d'être réaffectée (de manière similaire à la manière dont les final fonctionne en Java ou comment const fonctionne en JavaScript).

La différence est liée à la manière dont la mémoire est allouée. La mémoire est allouée pour un final au moment de l'exécution, et pour une variable const au moment de la compilation. Le site final devrait être le plus couramment utilisé, car de nombreuses variables de programme n'ont pas besoin de mémoire puisque la logique du programme ne demande pas leur initialisation. Avec un modificateur const variable, vous dites essentiellement à l'ordinateur : "Hé, j'ai besoin de mémoire pour cette variable dès le départ parce que je sais que je vais en avoir besoin".

En les considérant de cette manière, il est plus facile de comprendre les différences dans leur utilisation syntaxique. Principalement qu'un final peut être une variable d'instance, mais une const doit être un static sur une classe. En effet, les variables d'instance sont créées au moment de l'exécution, et const les variables, par définition, ne le sont pas. Ainsi, const Les variables d'une classe doivent être static ce qui signifie simplement qu'une seule copie de cette variable existe sur une classe, que cette classe soit instanciée ou non.

Cette vidéo explique les choses assez simplement : https://www.youtube.com/watch?v=9ZZL3iyf4Vk

Cet article va plus en profondeur et explique une différence sémantique très importante entre les deux, à savoir final modifie les variables et const modifie les valeurs, ce qui revient essentiellement à ne pouvoir qu'initialiser const qui sont dérivables au moment de la compilation.

https://news.dartlang.org/2012/06/const-static-final-oh-my.html