原始類型

JavaScript 有許多不同的原始類型 (MDN)

	範例	Flow 類型
布林值	true 或 false	boolean
字串	'foo'	string
數字	123	number
Null	null	null
Undefined	undefined	void
符號 (ES2015 新功能)	Symbol('foo')	symbol
BigInt (ES2020 新功能)	123n	bigint

有些原始類型會以文字值的形式出現在程式語言中

1true;2"hello";33.14;4null;5undefined;63n;

BigInt 和 Symbol 可以分別透過呼叫 BigInt 和 Symbol 來建立

1BigInt("2364023476023");2Symbol("hello");

文字值的 Flow 類型為小寫 (反映 JavaScript typeof 運算式 的輸出結果)

1function func(a: number, b: string, c: boolean, d: bigint) { /* ... */ }2
3func(3.14, "hello", true, 3n);

有些文字也可以用作文字型別

1function acceptTwo(x: 2) { /* ... */ }2
3acceptTwo(2); // Works!4acceptTwo(1); // Error!
           

4:11-4:11: Cannot call `acceptTwo` with `1` bound to `x` because number [1] is incompatible with number literal `2` [2]. [incompatible-call]

有些基本型別也可以包裝成物件

注意：您可能永遠都不會想要使用包裝物件變體。

1new Boolean(false);2new String("world");3new Number(42);

包裝物件的型別會大寫（與其建構函式相同）

1function func(x: Number, y: String, z: Boolean) {2  // ...3}4
5func(new Number(42), new String("world"), new Boolean(false));

這些包裝物件很少使用。

布林值

布林值在 JavaScript 中為 true 和 false 值。Flow 中的 boolean 型別接受這些值。

1function acceptsBoolean(value: boolean) { /* ... */ }2
3acceptsBoolean(true);  // Works!4acceptsBoolean(false); // Works!5
6acceptsBoolean("foo"); // Error!
                    

6:16-6:20: Cannot call `acceptsBoolean` with `"foo"` bound to `value` because string [1] is incompatible with boolean [2]. [incompatible-call]

JavaScript 也可以將其他型別的值隱式轉換為布林值。

if (42) {} // 42 => true
if ("") {} // "" => false

Flow 了解這些強制轉換，並允許它們作為 if 敘述的測試或其他條件語句的一部分。

若要將非布林值明確轉換為 boolean，可以使用 Boolean(x) 或 !!x。

1function acceptsBoolean(value: boolean) { /* ... */ }2
3acceptsBoolean(0);          // Error!
                4
5acceptsBoolean(Boolean(0)); // Works!6acceptsBoolean(!!0);        // Works!

3:16-3:16: Cannot call `acceptsBoolean` with `0` bound to `value` because number [1] is incompatible with boolean [2]. [incompatible-call]

您可以使用 typeof 檢查來限定一個值為 boolean

1function acceptsBoolean(value: boolean) { /* ... */ }2
3function func(value: mixed) {4  if (typeof value === 'boolean') {5    acceptsBoolean(value); // Works: `value` is `boolean`6  }7}

請記住，boolean 和 Boolean 是不同的型別。

• boolean 是文字值，例如 true 或 false，或表達式的結果，例如 a === b。
• Boolean 是由全域 new Boolean(x) 建構函式建立的包裝物件。您可能不想要使用這個！

數字

JavaScript 中的數字文字是浮點數，例如 42 或 3.14。JavaScript 也將 Infinity 和 NaN 視為數字。這些由 number 型別表示。JavaScript 也有單獨的BigInt 型別。

1function acceptsNumber(value: number) { /* ... */ }2
3acceptsNumber(42);       // Works!4acceptsNumber(3.14);     // Works!5acceptsNumber(NaN);      // Works!6acceptsNumber(Infinity); // Works!7
8acceptsNumber("foo");    // Error!
                   9acceptsNumber(123n);     // Error!
                  

8:15-8:19: Cannot call `acceptsNumber` with `"foo"` bound to `value` because string [1] is incompatible with number [2]. [incompatible-call]
9:15-9:18: Cannot call `acceptsNumber` with `123n` bound to `value` because bigint [1] is incompatible with number [2]. [incompatible-call]

您可以使用 typeof 檢查來限定一個值為 number

1function acceptsNumber(value: number) { /* ... */ }2
3function func(value: mixed) {4  if (typeof value === 'number') {5    acceptsNumber(value); // Works: `value` is `number`6  }7}

請記住，number 和 Number 是不同的型別。

• number 是文字值，例如 42 或 3.14，或表達式的結果，例如 parseFloat(x)。
• Number 是由全域 new Number(x) 建構函式建立的包裝物件。您可能不想要使用這個！

字串

字串在 JavaScript 中為 "foo" 值。Flow 中的 string 型別接受這些值。

1function acceptsString(value: string) { /* ... */ }2
3acceptsString("foo"); // Works!4acceptsString(`template literal`); // Works!5
6acceptsString(false); // Error!
                   

6:15-6:19: Cannot call `acceptsString` with `false` bound to `value` because boolean [1] is incompatible with string [2]. [incompatible-call]

JavaScript 會透過串接將其他型別的值隱式轉換為字串。

"foo" + 42; // "foo42"
"foo" + {}; // "foo[object Object]"

Flow 在將字串串接時只會接受字串和數字。

1"foo" + "foo"; // Works!2"foo" + 42;    // Works!3`foo ${42}`;   // Works!4
5"foo" + {};    // Error!
          6"foo" + [];    // Error!
          7`foo ${[]}`;   // Error!
         

5:1-5:10: Cannot use operator `+` with operands string [1] and object literal [2] [unsafe-addition]
6:1-6:10: Cannot use operator `+` with operands string [1] and empty array literal [2] [unsafe-addition]
7:8-7:9: Cannot coerce array literal to string because empty array literal [1] should not be coerced. [incompatible-type]

您必須明確地將其他型別轉換為字串。您可以使用 String 函式或使用其他字串化值的方法來執行此操作。

1"foo" + String({});     // Works!2"foo" + [].toString();  // Works!3"" + JSON.stringify({}) // Works!

您可以使用 typeof 檢查來限定一個值為 string

1function acceptsString(value: string) { /* ... */ }2
3function func(value: mixed) {4  if (typeof value === 'string') {5    acceptsString(value); // Works: `value` is `string`6  }7}

請記住，string 和 String 是不同的型別。

• 字串是一個文字值，例如"foo"或表達式的結果，例如"" + 42。
• 字串是由全域 new String(x) 建構函式建立的包裝物件。您可能不想使用它！

null 和 undefined

JavaScript 同時有 null 和 undefined。Flow 將它們視為不同的類型：null 和 void（代表 undefined）。

1function acceptsNull(value: null) { /* ... */ }2
3acceptsNull(null);      // Works!4acceptsNull(undefined); // Error!
                     5
6function acceptsUndefined(value: void) { /* ... */ }7
8acceptsUndefined(undefined); // Works!9acceptsUndefined(null);      // Error!
                     

4:13-4:21: Cannot call `acceptsNull` with `undefined` bound to `value` because undefined [1] is incompatible with null [2]. [incompatible-call]
9:18-9:21: Cannot call `acceptsUndefined` with `null` bound to `value` because null [1] is incompatible with undefined [2]. [incompatible-call]

您可以使用相等檢查將值精煉為 null 或 void

1function acceptsNull(value: null) { /* ... */ }2
3function func(value: mixed) {4  if (value === null) {5    acceptsNull(value); // Works: `value` is `null`6  }7}

1function acceptsUndefined(value: void) { /* ... */ }2
3function func(value: mixed) {4  if (value === undefined) {5    acceptsUndefined(value); // Works: `value` is `void`6  }7}

null 和 void 也出現在其他類型中

Maybe 類型

Maybe 類型用於值是選用的地方，您可以透過在類型前面加上問號來建立它們，例如 ?字串 或 ?數字。

?T 等於 T | null | void。

1function acceptsMaybeString(value: ?string) { /* ... */ }2
3acceptsMaybeString("bar");     // Works!4acceptsMaybeString(undefined); // Works!5acceptsMaybeString(null);      // Works!6acceptsMaybeString();          // Works!

要精煉，value == null 會同時精確檢查 null 和 undefined。

請閱讀Maybe 類型文件以取得更多詳細資訊。

物件選用屬性

物件類型可以有選用屬性，其中問號 ? 出現在屬性名稱之後。

{propertyName?: string}

除了設定值類型之外，這些選用屬性可以是 void 或完全省略。不過，它們不能是 null。

1function acceptsObject(value: {foo?: string}) { /* ... */ }2
3acceptsObject({foo: "bar"});     // Works!4acceptsObject({foo: undefined}); // Works!5acceptsObject({});               // Works!6
7acceptsObject({foo: null});      // Error!
                        

7:21-7:24: Cannot call `acceptsObject` with object literal bound to `value` because null [1] is incompatible with string [2] in property `foo`. [incompatible-call]

選用函式參數

函式可以有選用參數，其中問號 ? 出現在參數名稱之後。

function func(param?: string) { /* ... */ }

除了設定類型之外，這些選用參數可以是 void 或完全省略。不過，它們不能是 null。

1function acceptsOptionalString(value?: string) { /* ... */ }2
3acceptsOptionalString("bar");     // Works!4acceptsOptionalString(undefined); // Works!5acceptsOptionalString();          // Works!6
7acceptsOptionalString(null);      // Error!
                          

7:23-7:26: Cannot call `acceptsOptionalString` with `null` bound to `value` because null [1] is incompatible with string [2]. [incompatible-call]

具有預設值的函式參數

函數參數也可以有預設值。這是 ES2015 的一項功能。

function func(value: string = "default") { /* ... */ }

除了其設定的類型外，預設參數也可以是 void 或完全省略。但是，它們不能是 null。

1function acceptsOptionalString(value: string = "foo") { /* ... */ }2
3acceptsOptionalString("bar");     // Works!4acceptsOptionalString(undefined); // Works!5acceptsOptionalString();          // Works!6
7acceptsOptionalString(null);      // Error!
                          

7:23-7:26: Cannot call `acceptsOptionalString` with `null` bound to `value` because null [1] is incompatible with string [2]. [incompatible-call]

符號

符號在 JavaScript 中使用 Symbol() 建立。Flow 使用 symbol 類型，對符號提供基本支援。

1function acceptsSymbol(value: symbol) { /* ... */ }2
3acceptsSymbol(Symbol()); // Works!4acceptsSymbol(Symbol.isConcatSpreadable); // Works!5
6acceptsSymbol(false); // Error!
                   

6:15-6:19: Cannot call `acceptsSymbol` with `false` bound to `value` because boolean [1] is incompatible with symbol [2]. [incompatible-call]

你可以使用 typeof 檢查來將值限定為 symbol

1function acceptsSymbol(value: symbol) { /* ... */ }2
3function func(value: mixed) {4  if (typeof value === 'symbol') {5    acceptsSymbol(value); // Works: `value` is `symbol`6  }7}

BigInt

BigInt 可用於表示任意精度的整數。換句話說，它們可以儲存大到無法作為 number 儲存的整數。

bigint 文字只是一個 number 文字加上一個 n 字尾。

請注意，bigint 和 number 是不相容的類型。也就是說，bigint 不能用於預期 number 的地方，反之亦然。

1function acceptsBigInt(value: bigint) { /* ... */ }2
3acceptsBigInt(42n); // Works!4acceptsBigInt(42); // Error!
                

4:15-4:16: Cannot call `acceptsBigInt` with `42` bound to `value` because number [1] is incompatible with bigint [2]. [incompatible-call]

你可以使用 typeof 檢查來將值限定為 bigint

1function acceptsBigInt(value: bigint) { /* ... */ }2
3function func(value: mixed) {4  if (typeof value === 'bigint') {5    acceptsBigInt(value); // Works: `value` is `bigint`6  }7}