23

有没有办法利用初始化列表来选择性地初始化构造函数中的可选参数？以下示例在主体中使用if(?x)类型逻辑，因为不清楚如何仅在传入时在初始化列表中设置_x 。

class Point { 
    double _x = 0.0;
    double get x => _x;
    double _y = 0.0;
    double get y => _y;

    Point(
        {
        double x,
        double y
        })
    { 
        if(?x) { _x = x; }
        if(?y) { _y = y; }
    }
}

另一种方法是使用构造函数：

Point(
      {
        double x: 0.0,
        double y: 0.0
      }) : _x = x, _y = y
{
}

但是你在重复自己（0.0 多于一个地方），看起来 _x 和 _y 被初始化了两次，一次是针对成员，然后是初始化列表。此外，成员初始化器的一个好处是它可以是函数调用，而默认参数的默认值似乎需要常量。我希望/意识到性能影响很小。只想要一个很好的规范方法，可能用于代码生成。

4

3 回答 3

26

this您可以使用前缀在构造函数中初始化变量，例如：

class PointA { 
  double _x;
  double get x => _x;
  double _y;
  double get y => _y;

  PointA({double this._x=0.0, double this._y=0.0});
}

class PointB { 
  final double x;
  final double y;

  Point({double this.x=0.0, double this.y=0.0});
}

void main() {
  new PointA(_y:2.0); 
  new PointA(_x:3.0); 
  new PointA(_x:2.0, _y:3.0); 

  new PointB(y:2.0); 
  new PointB(x:3.0); 
  new PointB(x:2.0, y:3.0); 
}
于 2013-03-13T20:49:02.380 回答
12

Chris Buckett 的回答非常适合常量。显然有一个三元运算符在成员初始化程序中起作用。因此，如果字段的初始化很昂贵（比如需要函数调用和/或创建对象），这种方法似乎有效：

  • 不要费心初始化类中的成员 - 更喜欢构造函数。否则，可能是白费力气。
  • 跳过漂亮的this.member参数语法。而是使用成员名称并以此来限定成员。在作业中。
  • 在成员初始化程序中使用?parm和三元运算符。这是一个示例，其中假定为成员创建默认值是昂贵的。
class Formats {
  static Map<String, dynamic> defaultFormats() {
    print("Expensive call - avoid if possible");
    return {"th": 'default th', "td": 'default td'};
  }

  Map<String, dynamic> leftTbl;
  Map<String, dynamic> rightTbl;

  Formats(
      {Map<String, dynamic>? leftTbl,
      Map<String, dynamic>? rightTbl})
      : leftTbl = leftTbl ?? defaultFormats(),
        rightTbl = rightTbl ?? defaultFormats();

  @override
  String toString() {
    return """
l => $leftTbl,
r => $rightTbl
""";
  }
}

样品用途：

print(new Formats());
print(new Formats(leftTbl: {"th":'solid #089', "td":'solid #089' }));
print(new Formats(leftTbl: {"th":'solid #189', "td":'solid #189'},
      rightTbl: {"th":'solid #189', "td":'solid #189'}));

输出：

Expensive call - avoid if possible
Expensive call - avoid if possible
l => {th: default th, td: default td},
r => {th: default th, td: default td}

Expensive call - avoid if possible
l => {th: solid #089, td: solid #089},
r => {th: default th, td: default td}

l => {th: solid #189, td: solid #189},
r => {th: solid #189, td: solid #189}
于 2013-03-14T23:20:00.260 回答
6

作为对user1338952 答案的修改，您可以执行以下操作：

class Formats { 

  static Map<String,dynamic> defaultFormats() {
    print("Expensive call - avoid if possible");
    return { 
      "th" : 'default th',
      "td" : 'default td'
    };
  }

  Map<String,dynamic> leftTbl;
  Map<String,dynamic> rightTbl;

  Formats(
      {
        Map<String,dynamic> leftTbl,
        Map<String,dynamic> rightTbl
      }) : this.leftTbl = leftTbl ?? defaultFormats(),
           this.rightTbl = rightTbl??  defaultFormats()
  { 
  }

  String toString() {
    return """
l => $leftTbl,
r => $rightTbl
""";
  }
}

核心区别在于if null 运算符( ??) 的使用。

在this.leftTbl = leftTbl ?? defaultFormats()中，如果leftTbl为 null，defaultFormats()则简单地将返回的值分配给它。

于 2018-05-26T09:50:36.797 回答