typescript-类型

// 原始类型
let bool:boolean = true;
let num:number |undefined |null  = 123;
let str:string = "abc";
// str = 123;

// 数组

let arr1 : number[] = [1,2,3];
let arr2:Array<number> = [1,2,3];

let arr3: Array<number|boolean> = [1, 2, true]; //联合类型

// 元组
let tuple:[number,string] = [0,'1'];
tuple.push(2);
console.log(tuple);  
// 元组可以通过push添加元素， 但仍然不能越界访问。
// console.log(tuple[2])

// 函数
let add = (a:number , b:number):number => a + b  //因为ts的类型推断功能，返回值类型通常可以省略

let compute:(x:number,y:number) => number;  //函数定义没有具体实现
compute  = (a,b) => a + b;    //实现上边定义的 compute函数

// 对象
let obj:object = {x:1, y:2};
// obj.x = 3;   //只是简单的定义了 obj是 object类型 并没有指定具体有哪些属性

let obj1:{x:number,y:number} = {x:1,y:2};
obj1.x = 3; //这样才可以修改

// symbol
let  s1:symbol = Symbol();
let s2 = Symbol();
console.log(s1 === s2)  //symbol具有唯一性



// undefined null
let un:undefined = undefined;  //声明undefined类型的值  只能取undefined
let nu:null = null;    //声明null类型的值  只能取  null

// num = undefined;  //不能把undefined分配给类型number。
num = null;

//官方文档中  undefined 和null 是任何类型的子类型，这说明  undefined和null可以被赋值给其他类型。
// 更改 tsconfig.json中  strictNullChecks设置为false


// void
 let noReturn = () => {}  //没有返回值， 返回值类型就是void


//  any
let  x  //不指定变量的类型 默认就是any类型， 可以任意赋值

x = 1;
x = [];
x = ()=>{}


// never  表示永远不会有返回值的类型
let error = () =>{
    throw new Error('error');
}

let endless = () => {
    while(true){}
}


// 枚举类型 ：  一组有名字的常量集合。
// 数字枚举:  实现原理，反向映射
enum Role {
    Developer = 1,
    Reporter,
    Maintainer,
    Owner,
    Guest
}
console.log(Role.Reporter) //2

//字符串枚举 :不可以反向映射
enum  Message {  
    Success = "恭喜你，成功",
    Fail = "失败了"
}
console.log(Message.Fail)

// 异构枚举： 容易混淆，不建议使用
enum Answer {
    N,
    Y = "yes"
}

//枚举成员
enum Char {
    a,
    b = Char.a,
    c = 1+3,
    d = Math.random(),
    e = '123'.length
}
/**
 * 枚举成员的属性是只读的。
 */

//  常量枚举
 enum Month {
    Jan,
    Feb,
    Mar
}

// 枚举类型
enum E {a, b} 
enum F {a = 0, b = 1 }
enum G { a = "apple", b = "banana"}

let e:E = 3;
let f:F = 3;
// e === f  //不同枚举类型不能进行比较

let e1:E.a = 1 
let e2:E.b
// e1 === e2
let e3:E.a = 1

e1 === e3  //相同的枚举类型就可以比较

let g1:G = G.b
let g2:G.a
console.log(g1)