Literal Types(绝对类型)
flow不仅可以使用原始类型，还可以使用值作为类型注释。
// @flow
function acceptsTwo(value: 2) {
// ...
}
acceptsTwo(2); // Works!
// $ExpectError
acceptsTwo(3); // Error!
// $ExpectError
acceptsTwo("2"); // Error!
多个值
// @flow
function getColor(name: "success" | "warning" | "danger") {
switch (name) {
case "success" : return "green";
case "warning" : return "yellow";
case "danger" : return "red";
}
}
getColor("success"); // Works!
getColor("danger"); // Works!
// $ExpectError
getColor("error"); // Error!
Mixed Types(混合型)
单一类型
function square(n: number) {
return n * n;
}
多种类型
function stringifyBasicValue(value: string | number) {
return '' + value;
}
基于另一种类型的类型
返回值的类型与传入函数中的值的类型相同。
function identity<T>(value: T): T {
return value;
}
以上三种是比较常用的类型。
任意类型即混合型
function getTypeOf(value: mixed): string {
return typeof value;
}
进得去出不来
混合类型将接受所有的值。
// @flow
function stringify(value: mixed) {
// ...
}
stringify("foo");
stringify(3.14);
stringify(null);
stringify({});
当您尝试使用一个混合类型的值时，您必须首先弄清楚实际的类型是什么，否则将以错误告终。
// @flow
function stringify(value: mixed) {
// $ExpectError
return "" + value; // Error!
}
stringify("foo");
你必须来判断他是哪种值,代码才能运行
// @flow
function stringify(value: mixed) {
if (typeof value === 'string') {
return "" + value; // Works!
} else {
return "";
}
}
stringify("foo");
Any Types(任何类型)
如果你想要一种不进行类型检测的方法。可以使用任何类型，但是要尽量避免使用，这是完全不安全的。
// @flow
function add(one: any, two: any): number {
return one + two;
}
add(1, 2); // Works.
add("1", "2"); // Works.
add({}, []); // Works.
即使导致运行错误的代码也不会被捕获：
// @flow
function getNestedProperty(obj: any) {
return obj.foo.bar.baz;
}
getNestedProperty({});
只有几种情况可以考虑使用：
- 当您正在将现有代码转换为使用流类型的过程中，并且您当前在检查代码类型时被阻塞(可能需要首先转换其他代码)。
- 当您确定您的代码正常工作时，由于某种原因，Flow无法输入，请对其进行正确的检查。在JavaScript中，有越来越多的习惯用法无法静态地输入。
Avoid leaking any
当您有一个类型为Any的值时，您可以使Flow推断出您执行的所有操作的结果是any。\
如果您在输入ANY的对象上获得了一个属性，那么得到的值也将具有any类型。
// @flow
function fn(obj: any) {
let foo /* (:any) */ = obj.foo;
}
然后，您可以在另一个操作中使用结果值，例如将其添加为一个数字，结果也将是any。
// @flow
function fn(obj: any) {
let foo /* (:any) */ = obj.foo;
let bar /* (:any) */ = foo * 2;
}
然后把any暴露出去
// @flow
function fn(obj: any) /* (:any) */ {
let foo /* (:any) */ = obj.foo;
let bar /* (:any) */ = foo * 2;
return bar;
}
let bar /* (:any) */ = fn({ foo: 2 });
let baz /* (:any) */ = "baz:" + bar;
为了防止any类型暴露出去，我们可以如下做法：
// @flow
function fn(obj: any) {
let foo: number = obj.foo;
}
这样子的话，代码就不会把any类型暴露了，因为已经有个number类型接收。
// @flow
function fn(obj: any) /* (:number) */ {
let foo: number = obj.foo;
let bar /* (:number) */ = foo * 2;
return bar;
}
let bar /* (:number) */ = fn({ foo: 2 });
let baz /* (:string) */ = "baz:" + bar;
