• 添加类型注解的方式来检查代码
    • 需要 Flow 检查的文件首行以注解的方式添加 Flow （// flow） ```javascript // @flow function sum (a: number, b: number) { return a + b }

    sum(100, 100)

    2. - 通过编译移除【类型注解】
    4. .\node_modules\.bin\flow-remove-types src -d dist
    6. - 类型推断 （Type Inference）
    7. ```javascript
    8. /**
    9.  * 类型推断
    10.  * 
    11.  * @flow
    12.  */
    14. function square (n) {
    15.     return n * n   // 这里 Flow 会对下面调用传入的字符串进行判断，无法进行乘法运算，并会显示出错误
    16. }
    18. square('100')
    • 类型注解 （Type Annotations）
    1. /**
    2.  * 类型注解
    3.  * 
    4.  * @flow
    5.  */
    7. // 这里声明的时候是 number 类型
    8. let num: number = 100
    10. // 所以这里重新赋值 String 类型的时候，会提示语法错误
    11. // num = 'string'
    14. // 这里函数声明只允许返回 Number 类型的返回值
    15. function foo (): number {   // 如果没有 return 值回去，默认返回的 undefined, 所以这里的声明应该改成 void
    16.     // return 123
    18.     // return 'String'  // 这里返回 String 类型就会提示语法错误
    19. }
    • 原始类型 （primitive Types） ```javascript /**
      • 原始类型
      • @flow */

    // String 类型 const a: string = ‘asd’

    // Number 类型 const b: number = Infinity // NaN //100

    // 布尔类型 const c: boolean = false

    // Null const d: null = null

    // undefined const e: void = undefined

    // symbol const f: symbol = Symbol()

    
- 数组类型 （Array Types）
```javascript
/**
 * 数组类型
 * 
 * @flow
 */

const arr1: Array<number> = [1, 2, 3] // ['131']

const arr2: number[] = [1, 2, 3]

// 元组
const foo: [string, number] = ['foo', 123]
    • 对象类型 （Object Types） ```javascript /**
      • 对象类型
      • @flow */

    const obj1: { foo: string, bar: number } = { foo: ‘string’, bar: 100, name: ‘123’ }

    // 属性后面添加’?’,则该属性可有可无 const obj2: { foo?: string, bar: number } = { bar: 100, name: ‘123’ }

    // 可以添加任意数量的键和值，不限制名称，但是键值的类型必须是 string 类型 const obj3: { [string]: string } = {}

    obj3.key1 = ‘value1’

    // 这里就会提示语法错误 obj3.key2 = 100

    
- 函数类型 （Function Types）
```javascript
/**
 * 函数类型
 * 
 * @flow
 */

function foo (callback: (string, number) => void) {
    callback('string', 100)
}

foo(function (str, n) {
    console.log(str, n)
})
    • 特殊类型 ```javascript /**
      • 特殊类型
      • @flow */

    const a: ‘foo’ = ‘foo’

    const type: ‘success’ | ‘warning’ | ‘danger’ = ‘danger’

    type StringOrNumber = string | number

    const b: StringOrNumber = 100 // ‘string’

    // ————————————————

    // 相当于 const gender: number | null | void = undefined const gender: ?number = undefined

    
- Mixed & Any 任意类型
```javascript
/**
 * 任意类型
 * 
 * @flow
 */

//  mixed 所有类型的联合类型
function passMixed (value: mixed) {

}

// 这里可以传入任意类型
passMixed('string')


passMixed(100)

//  ----------------------------

// any 所有类型
function passAny (value: any) {
    console.log(arguments)
}

passAny('string')

passAny(100)

// any 和 mixed 的区别， any 是弱类型，而 mixed 是强类型
    • 类型小节

    https://flow.org/en/docs/types/
    https://www.saltycrane.com/cheat-sheets/flow-type/latest/