重要观念
万般皆对象，所有对象都是继承自Object类。不要求所有代码都必须定义在class中
Dart是强类型语言，但也支持类型推断。
支持泛型。
支持顶级函数（如main()）,也支持函数的嵌套。
支持顶级变量。
不支持
public,protected, 和private关键字，如果以下划线（_）开头定义，则为私有。所有的定义支持字母或下划线开头，后面紧跟字母、下划线或数字。
包括expressions（条件表达式，拥有运行时的值，如condition ? expr1 : expr2）和statements（声明表达式，不拥有运行时的值，如if-else），statements经常包含一致多个expressions，而expressions不能直接包含statements。
Dart tools 只汇报两种类型的问题: warnings 和errors， Warnings 只提示代码可能不工作，但不会阻止程序的执行，Errors发生在编译或者运行期，编译期的错误会中断代码执行，运行期的错误会导致程序运行发生异常。
类型声明规则
- 不能明确类型的地方需要显示声明类型，如方法的参数、返回值
install(id, destination) => ...//bad
Future<bool> install(PackageId id, String destination) => ...//good
- 避免在本地变量初始化的时候声明类型，
var desserts = <List<Ingredient>>[];//good
List<List<Ingredient>> desserts = <List<Ingredient>>[];//bad
List<AstNode> parameters;//good 未能推断出类型，需要明确类型
- 避免在函数表达式上注释推断的参数类型。
var names = people.map((person) => person.name);//good
var names = people.map((Person person) => person.name);//bad
- 避免在泛型调用上使用冗余类型参数。
Set<String> things = Set();//good
Set<String> things = Set<String>();//bad
var things = Set<String>();//good
var things = Set();//bad
- 如果推断的类型不正确，需要声明类型
// good
num highScore(List<num> scores) {
num highest = 0;
for (var score in scores) {
if (score > highest) highest = score;
}
return highest;
}
/** bad
当scores包含double类型时，如[1.2]，当赋值给highest是会发生异常，因为highest是num类型，而非num类型
**/
num highScore(List<num> scores) {
var highest = 0;
for (var score in scores) {
if (score > highest) highest = score;
}
return highest;
}
- 更喜欢用动态注释而不是让推理失败。
Dart在类型推断失败的情况下，会默认为dynamic类型，如果dynamic类型是你真正想要的，那么最好在声明时赋予
dynamic mergeJson(dynamic original, dynamic changes) => ...//good
mergeJson(original, changes) => ...//bad
- 首选函数类型批注中的签名。
bool isValid(String value, bool Function(String) test) => ...//good
bool isValid(String value, Function test) => ...//bad
//good
void handleError(void Function() operation, Function errorHandler) {
try {
operation();
} catch (err, stack) {
if (errorHandler is Function(Object)) {
errorHandler(err);
} else if (errorHandler is Function(Object, StackTrace)) {
errorHandler(err, stack);
} else {
throw ArgumentError("errorHandler has wrong signature.");
}
}
}
- 不要为setter指定返回类型。
void set foo(Foo value) { ... }//bad
set foo(Foo value) { ... }//good
- 不要使用旧的typedef语法。
//旧，bad
typedef int Comparison<T>(T a, T b);
typedef bool TestNumber(num);
//新，good
typedef Comparison<T> = int Function(T, T);
typedef Comparison<T> = int Function(T a, T b);
- 首选内联函数类型而不是typedef。
class FilteredObservable {
final bool Function(Event) _predicate;
final List<void Function(Event)> _observers;
FilteredObservable(this._predicate, this._observers);
void Function(Event) notify(Event event) {
if (!_predicate(event)) return null;
void Function(Event) last;
for (var observer in _observers) {
observer(event);
last = observer;
}
return last;
}
}
- 考虑对参数使用函数类型语法。
Iterable<T> where(bool Function(T) predicate) => ...
- 使用Object而不是dynamic进行注释，以指示允许使用任何对象。
使用dynamic会发送更复杂的信号。这可能意味着DART的类型系统不够复杂，无法表示所允许的一组类型，或者值来自互操作或静态类型系统的权限之外，或者您明确希望在程序中的该点具有运行时动态性。
void log(Object object) {
print(object.toString());
}
/// Returns a Boolean representation for [arg], which must
/// be a String or bool.
bool convertToBool(dynamic arg) {
if (arg is bool) return arg;
if (arg is String) return arg == 'true';
throw ArgumentError('Cannot convert $arg to a bool.');
}
- 将Future<void>用作不生成值的异步成员的返回类型。
- 避免使用FutureOr<T>作为返回类型。
如果一个方法接收FutureOr<int>作为参数，意味着使用时可以传参为int或Future<int>。所以如果你的返回类型FutureOr<int>,则使用方还需要判断是int还是Future<int>
Future<int> triple(FutureOr<int> value) async => (await value) * 3;//good
//bad
FutureOr<int> triple(FutureOr<int> value) {
if (value is int) return value * 3;
return (value as Future<int>).then((v) => v * 3);
}
//good
Stream<S> asyncMap<T, S>(
Iterable<T> iterable, FutureOr<S> Function(T) callback) async* {
for (var element in iterable) {
yield await callback(element);
}
}
参数声明规则
- 避免定位布尔参数。
//bad
new Task(true);
new Task(false);
new ListBox(false, true, true);
new Button(false);
//good，考虑使用命名的参数，增加构造函数，或使用常量
Task.oneShot();
Task.repeating();
ListBox(scroll: true, showScrollbars: true);
Button(ButtonState.enabled);
//good
listBox.canScroll = true;
button.isEnabled = false;
- 如果用户可能希望省略前面的参数，请避免使用可选的位置参数。
String.fromCharCodes(Iterable<int> charCodes, [int start = 0, int end]);
DateTime(int year,
[int month = 1,
int day = 1,
int hour = 0,
int minute = 0,
int second = 0,
int millisecond = 0,
int microsecond = 0]);
Duration(
{int days = 0,
int hours = 0,
int minutes = 0,
int seconds = 0,
int milliseconds = 0,
int microseconds = 0});
- 避免使用接受特殊“无参数”值的强制参数。
var rest = string.substring(start);//good
var rest = string.substring(start, null);//bad
- 使用inclusive start和exclusive end参数接受范围。
[0, 1, 2, 3].sublist(1, 3) // [1, 2]
'abcd'.substring(1, 3) // 'bc'
Equality
- DO override hashCode if you override ==.
- 一定要使==运算符遵守相应的数学规则。
Reflexive: a == a should always return true.
Symmetric: a == b should return the same thing as b == a.
Transitive: If a == b and b == c both return true, then a == c should too.
- 避免为可变类定义自定义相等。
- 不要在custom的==运算符中检查空值。
The language specifies that this check is done automatically and your == method is called only if the right-hand side is not null.
//good
class Person {
final String name;
// ···
bool operator ==(other) => other is Person && name == other.name;
int get hashCode => name.hashCode;
}
//bad
class Person {
final String name;
// ···
bool operator ==(other) => other != null && ...
}
