TS类型声明

编译

tsc xxx.ts  

变量声明&赋值

let a: number
a = 10
let c: boolean = true
let c = false   //TS声明和赋值同时进行，自动对变量进行类型检测

//JS中函数不考虑参数的类型和个数

function sum(a: number, b: number): number{    //指定形参和返回值类型
    return a + b
}

 类型：

类型	例子	描述
number	1, -2, 2.5	任意数字
string	'hi', "hello", hi	任意字符串
boolean	true、false	布尔值true或false
字面量	其本身	限制变量的值就是该字面量的值
any	*	任意类型
unknown	*	类型安全的any
void	空值(undefined)	没有值(或undefined)
never	没有值	不能是任何值
object	{name:'孙悟空'}	任意的JS对象
array	[1,2,3]	任意JS数组
tuple	[4,5]	元素，TS新增类型，固定长度数组
enum	enum{A,B}	枚举，TS中新增类型

//字面量进行类型声明,不可修改
let a: 10
//联合类型
let b: 'male' | 'female'
b = 'male'
b = 'female'

let c: boolean | string
c = true
c = 'hello'
//任意类型，相当于关闭了TS的类型检测（不建议）
let d:any
d = 10
d = 'hello'
d = true

//不指定类型，TS解析器会自动判断变量的类型为any（隐式的any）
let d;

//unknown 表示未知类型
let e: unknown;
e = 10;
e = 'hello';
e = true

//d的类型是any，它可以赋值给任意变量(污染其他变量）
let s: string;
s = d; //true

//e为未知类型，赋值给s 报错
e = 'hello'
s = e;

if(typeof e === 'string'){
    s = e
}

//类型断言，可以用来告诉解析器变量的实际类型
s = e as string;
s = <string>e;

//函数类型为void，依据返回值类型
function fn(): void{    //表示没有返回值
}

//never 表示永远不会返回结果，无空
function fn2(): never{
    throw new Error('报错');
}

//object表示一个JS对象
let a: object;
a = {};
a = function () {
};
//{}用来指定对象中可以包含哪些属性
//在属性名后加？表示属性名可选
let b: {name: string, age?: number};
b = {name: '孙悟空'}; 

//任意字符串形式的属性名，任意类型
let c: {name: string, [propName: string]: any}
c = {name: '猪八戒', a: 1, b: 2}

//定义函数： （形参：类型）=> 返回值类型
let d: (a: number, b: number)=>number;
d = function (n1, n2): number{
    return n1 + n2
}

//string[]表示字符串数组
let e: string[]
e = ['a', 'b', 'c']

//number[]数值数组
let f: number[];

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

元组：固定长度的数组

//语法：[类型，类型]
let h: [string, string]
h = ['hello', 'abc']

//enum枚举
enum Gender{
    Male = 0,
    Female = 1
}

let i: {name:string, gender:Gender}
i = {
        name:'孙悟空',
        gender:Gender.Male    //male
}
console.log(i.gender === Gender.Male)

//&表示同时
let j: { name: string } & { age: number };
j = { name: '孙悟空', age: 18 }

//类型的别名
type myType = 1 | 2 | 3 | 4 | 5;
let k: myType;
let l: myType;

let m: myType;

k = 1;