函数详解Dart性能优化之常量、常量构造

const、final区别

const 声明的常量是在编译时确定的，永远不会改变。
final 声明的常量允许声明后再赋值，赋值后不可改变，final 声明的变量是在运行时确定的
final 不仅有const的编译时常量的特性，最重要的它是运行时常量，并且是惰性初始化

final和const区别：final可以开始不赋值，只能赋值一次；而且final有const的编译时常量的特性

 //const 常量
  var PI = 3.14;
  PI = 3.12415;
  print(PI);//3.12415

  const PID = 3.14;
  // PID = 3.12415; const定义的常量无法改变
  print(PID);//3.14

  //final 常量
  final PIF = 3.14;
  // PIF = 3.12415;   无法改变
  print(PIF);//3.14

  //final和const区别：final可以开始不赋值，只能赋值一次；而且final有const的编译时常量的特性
  final PIE;
  PIE = 333;
  // PIE = 444; 不能再次赋值
  print(PIE);//333

  final currentTime = DateTime.now(); //获取当前时间
  print(currentTime);//2025-04-28 10:16:36.036833

通过identical函数用法介绍、检查两个引用是否指向同一个对象

  var object1 = Object();
  var object2 = Object();
  //判断object1、object2是否共用同一个存储空间？是否指向同一个对象？
  print(identical(object1, object2)); //false
  print(identical(object1, object1)); //true

  //表示实例化常量构造函数   const 关键词在多个地方创建相同的对象时候，内存中只保留了一个对象
  //o1和o2共享了存储空间
  var object3 = const Object();
  var object4 = const Object();
  print(identical(object3, object4)); //true
  print(identical(object4, object4)); //true

  print(identical([2], [2])); //false 指向了两个对象
  print(identical(const [2], const [2])); //true 指向了两个对象

  var a = [2];
  var b = [2];
  print(identical(a, b)); //false 指向了两个对象

  //通过const定义的常量，它俩值要相等，才会指向了一个对象，使用同一存储空间
  const c = [2];
  const f = [2];
  print(identical(c, f)); //true 指向了两个对象

普通构造函数

main(){
 //普通构造函数
  var container1 = Container1(width: 100, height: 100);
  var container2 = Container1(width: 100, height: 100);
  print(identical(container1, container2)); //false 指向了两个对象 在内存中存储了2份
}


//普通构造函数
class Container1 {
  int width;
  int height;

  Container1({required this.width, required this.height});
}

常量构造函数

1.常量构造函数需以const关键字修饰
2.const构造函数必须用于成员变量都是final的类
3.如果实例化时不加const修饰符，即使掉用的是常量构造函数，实例化的对象也不是常量实例
4.实例化常量构造函数的时候，多个地方创建这个对象，如果传入的值相同，只会保留一个对象
5.Flutter中const 修饰不仅仅是节省组在需要重新构建组件构建时的内存开销，Flutter在需要重新构建组件时是不改变的，重新构建没有任何意义，因此Flutter不会重建构建const组件

main(){
  var container3 = Container2(width: 100, height: 100);
  var container4 = Container2(width: 100, height: 100);
  print(identical(container3, container4)); //false 指向了两个对象 在内存中存储了2份

  var container5 = const Container2(width: 100, height: 100);
  var container6 = const Container2(width: 100, height: 100);
  print(identical(container5, container6)); //true 指向了1个对象 在内存中存储了1份

  //值不一样，还是会保留2个对象
  var container7 = const Container2(width: 110, height: 100);
  var container8 = const Container2(width: 100, height: 110);
  print(identical(container7, container8)); //false 指向了两个对象 在内存中存储了2份
}


//常量构造函数
class Container2 {
  final int width;//先声明，后赋值
  final int height;

  const Container2({required this.width, required this.height});
}