Dart 命名构造函数与 Static 方法更喜欢什么？

Question

So after dart made new keyword optional,

we can initialize an object with exact same syntax but different internal implementation .

class Color {
  int r = 0, g = 0, b = 0;

  Color({this.r, this.b, this.g});

  //Named constructors
  Color.red() //Implementation

  Color.cyan() //Implementation

  // Static Initializers
  static Color red() => //Initialze with parameter

  static Color cyan() => //Initialze with parameter
}

We can use them like this regardless of being it a named constructor or static method :

Color red = Color.red();
Color cyan = Color.cyan();

What is the place to use each of them?

Answer 1

Constructors and static functions are different. You usually create a named constructor that returns an instance of an object with some predefined values. For example, you have a class called Person which stores Name and Job . You can create this named constructer Person.doctor(name) which you will return a Person object with Job = 'doctor'

 class Person{
  final name;
  final job;

  Person(this.name, this.job);

  Person.doctor(this.name, {this.job = "doctor"});

 }

Static functions or variable persists on all the instance of a class. Let us say, Person has a static variable called count . You increment the count variable whenever an instance of Person is created. You can call Person.count anywhere later in your code to get the value of count (Number of instances of Person )

class Person{
  final name;
  final job;
  static int count;

  Person(this.name, this.job){
    count++;
  }

  Person.doctor(this.name, {this.job = "doctor"});

}

Answer 2

In practice there is little difference between a factory constructor and a static method.

For a generic class, it changes where you can (and must) write a type parameter:

class Box<T> {
  T value;
  Box._(this.value);
  factory Box.withValue(this.value) => Box<T>._(value);
  static Box<T> fromValue<T>(T value) => Box<T>._(value);
}
...
  var box1 = Box<int>.withValue(1);
  var box2 = Box.fromValue<int>(2);

So, for generic classes, factory constructors are often what you want. They have the most pleasant syntax.

For non-generic classes, there is very little difference, so it's mainly about signaling intent. And deciding which category the name goes into in the DartDoc.

If the main objective of the function is to create a new object, make it a constructor.

If the main objective is to do some computation and eventually return an object (even if it's a new object), make it a static function. That's why parse methods are generally static functions.

In short, do what feels right for your API.

Answer 3

Another benefit of the distinction between named constructor and static function is that in the documentation generated the function will be either filed in the construction section or the methods section, which further makes it's intentions clearer to the reader.

A person looking for a constructor in the constructor section of the documentation will easily discover the named constructors as opposed to having to also dig through the static functions section too.

Answer 4

Another very useful feature of static class methods is that you can make them asynchronous, ie wait for full initialisation in case this depends on some asynchronous operation:

Future<double> getCurrentPrice(String ticker) async {
  double price;
  // for example, fetch current price from API
    price = 582.18;
  return price;
}

class Stock {
      String ticker;
      double currentPrice=0.0;
      
      Stock._(this.ticker);
      
      static Future<Stock> stockWithCurrentPrice(String ticker) async {
        Stock stock = Stock._(ticker);
        stock.currentPrice =  await getCurrentPrice (ticker);
        return stock;
      }
}

void main() async {
  Stock stock = await Stock.stockWithCurrentPrice('AAPL');
  print ('${stock.ticker}: ${stock.currentPrice}');
}