let const

let name = 'WJ';
let info:{name:string | number} ;
info = {name:'WJ'};
info = 404

类型推断

当未明确给出类型时，会在第一次赋值时，根据值来推断类型

let x = 'WJ';   // x未定义类型，但赋值字符串'WJ'，那么x的类型和'WJ'一样，类型是string
x = 18;         // 错误：因为x是字符串
x = 'WanJin';   // 正确

数组解构

let [a, b] = [1,2];         // a:1, b:2
let [a, ...b] = [1,2,3,4];  // a:1; b:[2,3,4]
let [,a,,b] = [1,2,3,4];    //a:2; b:4

对象解构

let {a, b} = {b:3, a:1};    // a:1, b:3
let {a, ...obj} = {a:1, b:2,c:3};    // a:1, obj:{b:2,c:3}
({a, b} = {b:3, a:1});      // 同上

数组展开

[1, ...[2,3], ...[4] ]; // [1,2,3,4]

对象展开

{ a:1, ...{b:2, c:3}};  // {a:1, b:2, c:3}

两个变量是对象，进行赋值

被赋值对象的所有属性，在所赋值中必须全部存在

let x = {name:'WJ'}
let y = {name:'WanJin',age:18}
x = y;  // 正确：x的属性name，能在y中找到
y = x;  // 错误：y的属性age，无法在x中找到

两个变量是函数，进行赋值

与上面对象赋值刚好相反
所赋值函数的参数，在被赋值函数中必须全部存在
参数名可以不同，但是类型和顺序必须一致

let  func_x = (a:number)=>0;
let func_y = (b:number, c:string)=>0;
func_x = func_y;  // 错误：func_y中的参数c，无法在func_x中找到
func_y = func_x;  // 正确：func_x中参数a，可以在func_y中找到

就算参数是对象，也要比较对象的属性

let x = () => ({name: 'Alice'});
let y = () => ({name: 'Alice', location: 'Seattle'});

x = y; // 正确
y = x; // 错误

两个变量是类，进行赋值

与对象类似，但是只检测可实例部分属性和方法，不检测静态的（比如构造函数等）
private、protected属性必须都存在

class PERSON {
    name:string;
    constructor(name:string, age:number){}
}
class STUDENT {
    name:string;
    constructor(name:string){}
}
let person : PERSON;
let student : STUDENT
person = student;  // 正确
student = person;  // 正确

两个枚举，进行复制

不同枚举，不能赋值

enum PERSON {
    name

}

enum STUDENT {
    name=3
}

let person = PERSON.name;
person = STUDENT.name;    // 错误