各类型定义

1、类型定义

let flag:boolean = false; // 布尔类型
let num:number = 15; // 数值类型 
let str:string = 'abc'; // 字符串类型 
let str2:string=`hello,${str}`;
let msg:string = `hello,${str},${num}`;
let u: undefined = undefined;
let n: null = null;
1
2
3
4
5
6
7

任意值

如果是一个普通类型，在赋值过程中改变类型是不被允许的，任意值（Any）用来表示允许赋值为任意
类型。

let a1: string = 'seven'; 
a1 = 7;// error 但如果是 any 类型，则允许被赋值为任意类型。
let a2: any = 'seven'; 
a2 = 7; 
变量如果在声明的时候，未指定其类型，那么它会被识别为任意值类型
let a3;
a3 = 'seven';
a3 = 7;
相当于
let a3:any;
a3 = 'seven'; 
a3 = 7;
1
2
3
4
5
6
7
8
9
10
11
12

联合类型

表示取值可以为多种类型中的一种

let a4: string | number;
a4 = 'seven';
a4 = 7;
a4 = true; // 不行
1
2
3
4

function getLength(str: string | number): number { 
	return str.length; 
	//会报错，为什么？ 
}
console.log(getLength(123)); 

// 当 TypeScript 不确定一个联合类型的变量到底是哪个类型的时候，只能访问此联合类型的所有类型里共有的属性或方法 

function getLength(str: string | number[]): number {
	return str.length;
}
console.log(getLength([1,2,3]));
1
2
3
4
5
6
7
8
9
10
11
12

2、数组类型的定义

在 TypeScript 中，数组类型有多种定义方式，比较灵活。最简单的方法是使用「类型 + 方括号」来表示数组：

let arr: number[] = [1, 2, 3, 4, 5]; 
// 数组的项中不允许出现其他的类型
let arr: number[] = [1, '2', 3, 4, 'a']; // 不行
// 其它类型的数组
let arr2: any[] = [1, '1', 2, 'x', {id:1},[1,2,3],true];
let arr3: string[] = ['x', 'y', '2', '3', '5'];
1
2
3
4
5
6

泛型（Generics）是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定
类型的一种特性。 泛型变量 ，表示任何类型。

let arr:Array<number> =[1,2,3]; 
// 定义多个类型
let arr:Array<number|string> =['1',2,3];
1
2
3

3、对象的类型—接口

在面向对象语言中，接口（Interfaces）是一个很重要的概念，它是对行为的抽象接口（Interfaces）可以用于对「对象的形状（Shape）」进行描述。

// 接口的定义，接口首字母大写
interface Person { 
	name: string;
	age: number;
}
let tom: Person = { 
	name: 'Tom',
	age: 18
};
//上面的例子中，我们定义了一个接口 Person，接着定义了一个变量 tom，它的类型是 Person。 这样，我们就约束了 tom 的形状必须和接口 Person 一致。
1
2
3
4
5
6
7
8
9
10

定义的变量比接口少了一些属性是不允许的：

let tom2: Person = { 
	name: 'Tom'
};
let tom3: Person = {
	name: 'Tom',
	age: 25,
	sex: '男'
};
1
2
3
4
5
6
7
8

接口能否更灵活？可以使用可选属性：

interface Person2 {
	name: string;
	age?: number;
}
let tom4: Person2 = { 
	name: 'Tom'
};
// 可选属性的含义是该属性可以不存在。这时仍然不允许添加未定义的属性：
let tom5: Person2 = {
	name: 'Tom',
	age: 25,
	sex: '男'// 还是不行
};
1
2
3
4
5
6
7
8
9
10
11
12
13

任意属性 ：一个接口允许有任意的属性

interface Person3 {
	name: string;
	age?: number;
	[propName: string]: any;
};

let tom6: Person3 = {
	name: 'Tom',
	sex: '男'
};
1
2
3
4
5
6
7
8
9
10

需要注意的是，一旦定义了任意属性，那么确定属性和可选属性都必须是它的子属性。

interface Person4 {
	name: string;
	age?: number;
	[propName: string]: any;
};
let tom7: Person4 = {
	name: 'Tom',
	sex: '男'
};
1
2
3
4
5
6
7
8
9

4、函数的类型定义

一个函数有输入和输出，要在 TypeScript 中对其进行约束，需要把输入和输出都考虑到

function sum1(x: number, y: number): number { 
	return x + y;
}
1
2
3

参数默认值

function sum3(x: number=5, y: number): number {
	return x + y;
}
let s1 = sum3(1, 2);
1
2
3
4

可选参数

function sum4(x: number, y?: number): number[] {
	return [x,y]
}
let s2 = sum4(1);
1
2
3
4

泛型

什么时候需要定义泛型函数？要创建一个可重用的组件，其中的数据类型就必须要兼容很多的类型，那么如何兼容呢？

// 定义一个只能传入number类型的函数
function f(a:number,b:number):number[]{
	return [a,b]
}
f(1,2);
// 定义一个只能传入string类型的函数
function f2(a:string, b:string):string[]{
	return [a,b]
}
f2('1','3') 
// 泛型的定义
function f3<T>(a:T,b:T):T[]{
	return [a,b]
}
f3<number>(1,2)
f3<string>('a','b')
// 我们把f3这个函数叫做泛型，因为它适用于所有类型，并且不会有any类型存在的问题，使用“类型变量”一种特殊的变量，代表的是类型而非值 在泛型中，我们要合理正确的使用泛型变量T，要牢记T表示任何类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

一旦我们定义了泛型函数，有两种方法可以使用。第一种就是传入所有的参数，包括类型参数：

f3<string>(1,2); 
f3<string | number>(1,'2');
1
2