1. TS 基础类型

// 基础类型
let name: string = "zhyangsan"
let age: number = 18
let handsome: boolean = true

// 大写的类型都是装箱类型，装箱类型兼容基础类型
let s1: string = "abc"
let s2: string = new String() // ts 提示：不能把 String 分配给 string
let s3: String = "abc"
let s4: String = new String("abc")

// 数组类型
let arr1: number[] = [1, 2, 3, 4, 5]
let arr2: string[] = ['1', '2', '3', '4', '5']
let arr3: (number | string)[] = [1, '2', 3]
let arr4: Array<number | string> = [1, '2', 3, '4']

// 元组：规定长度和存储类型
let tuple1: [string, number, boolean] = ["zhangsan", 18, true]

tuple1.push('abc')
console.log(tuple1[3]) // ts 报错，虽然添加了，但是访问不到 tuple1[3] 元素

// 枚举,自带类型，自动增长
enum USER_ROLE {
    USER,    // USER_ROLE.USER = 0
    ADMIN,   // 1
    MANAGER, // 2
    OTHER = "ABC" // 异构枚举，枚举对象中加入不同的类型的变量
}
// 编译之后
var USER_ROLE;
(function (USER_ROLE) {
    USER_ROLE[USER_ROLE["USER"] = 0] = "USER";
    USER_ROLE[USER_ROLE["ADMIN"] = 1] = "ADMIN";
    USER_ROLE[USER_ROLE["MANAGER"] = 2] = "MANAGER";
    USER_ROLE["OTHER"] = "ABC";
})(USER_ROLE || (USER_ROLE = {}));


// 常量枚举,如果只是使用值，可以直接使用常量枚举，否则使用普通枚举
const enum MANAGER_ROLE {
    MANAGER1,
    MANAGER2,
    MANAGER3
}
console.log(MANAGER_ROLE.MANAGER1) 
// 编译后
console.log(0 /* MANAGER_ROLE.MANAGER1 */);

// null 和 undefined
// 任何类型的子类型，严格模式关掉生效
let nullStr: string = null
let udfStr: string = undefined

// void 函数的返回值为空,undefined是子类型，可以赋值给void
function fn(): void {
    return undefined
}

// never 类型
// 任何类型的子类型
function fn1(): never {
    // throw new Error()
    while(true){}
}
let bar:string = fn1() // never 任何类型的子类型

// 类型保护，保障程序的不缺失，完整性保护
function validate(val:never){}
function getLastResult(stringOrNumberOrBoolean: string | number | boolean) {
    if(typeof stringOrNumberOrBoolean === 'string'){
        return stringOrNumberOrBoolean;
    }
    if(typeof stringOrNumberOrBoolean === 'number'){
        return stringOrNumberOrBoolean
    }
    validate(stringOrNumberOrBoolean) // ts 提示：boolean 类型不能赋值给 never 类型，保证程序完整性
}

// never 和其他类型做联合类型最终是不显示的
let union: string | number | boolean | never; // string | number | boolean

// any 类型
// any 会导致类型丧失检测
let a1:any = 1;
a1 = '1';

// object 引用类型
function create(val:object){}

create({})
create([])
create(function(){})

const 定义的类型是字面量类型，const 声明变量一定要赋值。
let a = 1 // a: number
const a // 'const' declarations must be initialized
const a = 1 // const a: 1