定义兼容性对象数组T 表示传入的类型，可以为number、string、boolean等
 
 
传入什么label就是什么类型
 
 
interface labelValue {
  
 
 
label: T;
 
 
value: number;
 
 
}
 
 
// 传入number类型
 
 
let obj: labelValue;
 
 
export function formatYear (): labelValue[] {
  
 
 
let date = new Date().getFullYear();
 
 
let arr: labelValue[];
 
 
for (let i = 0; i < date + 10; i++) {
  
 
 
obj = {
  
 
 
label: i,
 
 
value: i
 
 
}
 
 
arr.push(obj)
 
 
}
 
 
return arr;
 
 
}
 
 
// 传入string类型
 
 
let obj1: labelValue;
 
 
export function formatHours (): labelValue[] {
  
 
 
let arr: labelValue[];
 
 
for (let i = 0; i <= 24 + 10; i++) {
  
 
 
obj1 = {
  
 
 
label: i + 'h',
 
 
value: i
 
 
}
 
 
arr.push(obj1)
 
 
}
 
 
return arr;
 
 
}
 
 
定义对象型数组
 <

 
对象类型
 
基础使用
 
在 TypeScript 中，我们使用接口(Interfaces)来定义对象的类型。
 
简单例子：
 
interface Person {
 
name: string;
 
age: number;
 
}
 
let tom: Person = {
 
name: 'Tom',
 
age: 25
 
};
 
复制代码
 
上面的例子中，我们定义了一个接口 Person，接着定义了一个变量 tom，它的类型是 Person。这样，我们就约束了 tom 的形状必须和接口 Person 一致。
 
定义的变量比接口少/多了属性是不允许的：
 
interface Person {
 
name: string;
 
age: number;
 
}
 
let tom: Person = {
 
name: 'Tom'
 
};
 
let tom: Person = {
 
name: 'Tom',
 
age: 25,
 
gender: 'male'
 
};
 
//都会报错哦
 
复制代码可选属性
 
但是有些时候，我们并不希望对象的形状完全遵守接口的定义(我们希望少/多些属性)：
 
所以我们会用到可选属性
 
interface Person {
 
name: string;
 
age?: number;
 
}
 
let tom: Person = {
 
name: 'Tom'
 
};
 
// 特征是打了个问号，意味着并不是必须的，而是可选的属性
 
//但是这个时候可以少属性，却不能多属性
 
复制代码任意属性
 
我们会使用任意属性来实现可以少属性/多属性
 
interface Person {
 
name: string;
 
age?: number;
 
[propName: string]: any;
 
}
 
let tom: Person = {
 
name: 'Tom',
 
gender: 'male'
 
};
 
复制代码
 
需要注意的是，一旦定义了任意属性，那么确定属性和可选属性的类型都必须是它的类型的子集:
 
interface Person {
 
name: string;
 
age?: number;
 
[propName: string]: string; // 任意属性只包含了string类型
 
}
 
let tom: Person = {
 
name: 'Tom',
 
age: 25, // age的nubmer属性不在任意属性string内，会报错
 
gender: 'male'
 
};
 
复制代码只读属性
 
有时候我们希望对象中的一些字段只能在创建的时候被赋值，那么可以用 readonly 定义只读属性：
 
interface Person {
 
readonly id: number;
 
name: string;
 
age?: number;
 
[propName: string]: any;
 
}
 
let tom: Person = {
 
id: 89757,
 
name: 'Tom',
 
gender: 'male'
 
};
 
tom.id = 9527;// 该属性只读，赋值操作会报错
 
复制代码数组类型
 
数组类型会对其的内容进行约束
 
「类型 + 方括号」表示法
 
let fibonacci: number[] = [1, 1, 2, 3, 5];
 
复制代码数组泛型
 
let fibonacci: Array = [1, 1, 2, 3, 5];
 
复制代码用接口(interface)表示数组
 
interface NumberArray {
 
[index: number]: number;
 
}
 
let fibonacci: NumberArray = [1, 1, 2, 3, 5];
 
复制代码类数组不能使用以上3钟形式去表示
 
function sum() {
 
let args: {
 
[index: number]: number;
 
length: number;
 
callee: Function;
 
} = arguments;
 
}
 
复制代码函数类型
 
函数声明
 
函数表达式
 
在 JavaScript 中，有两种常见的定义函数的方式如上。
 
一个函数有输入和输出，所以基本上就是把约束覆盖到函数的输入与输出上。
 
1. 传统的定义函数的输入与输出
 
// 函数声明的写法
 
function sum(x: number, y: number): number {
 
return x + y;
 
}
 
// 多参数 | 少参数 是不被允许的哦
 
// 函数表达式的写法，等式左边的可以被省略而完全又右边类型判断出来。
 
let mySum: (x: number, y: number) => number = function (x: number, y: number): number {
 
return x + y;
 
};
 
复制代码
 
2. 用接口定义函数的输入与输出
 
interface SearchFunc {
 
(source: string, subString: string): boolean;
 
}
 
let mySearch: SearchFunc = function(source: string, subString: string) {
 
return source.search(subString) !== -1;
 
}
 
复制代码
 
- 函数的参数详情
 
前面我们提到，输入多/少的参数式不被允许的，这在接口定义中也存在着这个限制，同样的，我们也可以使用？来定义可选参数
 
！！！可选参数必须接在必需参数后面，否则会报错。如下是正确写法
 
function buildName(firstName: string, lastName?: string) {
 
if (lastName) {
 
return firstName + ' ' + lastName;
 
} else {
 
return firstName;
 
}
 
}
 
let tomcat = buildName('Tom', 'Cat');
 
let tom = buildName('Tom');
 
复制代码
 
参数也可以拥有默认值, TypeScript 会将添加了默认值的参数识别为可选参数,此时就不受「可选参数必须接在必需参数后面」的限制了：
 
function buildName(firstName: string, lastName: string = 'Cat') {
 
return firstName + ' ' + lastName;
 
}
 
let tomcat = buildName('Tom', 'Cat');
 
let tom = buildName('Tom');
 
复制代码
 
- 函数的重载
 
这个挺……无语的，感觉很没必要
 
function reverse(x: number | string): number | string {
 
if (typeof x === 'number') {
 
return Number(x.toString().split('').reverse().join(''));
 
} else if (typeof x === 'string') {
 
return x.split('').reverse().join('');
 
}
 
}
 
复制代码本教程完全依赖于 ： https://ts.xcatliu.com/introduction/index.html
 
复制代码

上面已经做过数组内存在单个或多个类型一样的数组的类型定义，再复习下
 
const arrA = [1, 2, 4] // 这里利用ts 的类型推断，arrA的数组类型定义为：
const arrA: number[] = [1, 2, 4]
 
数组中存在单个或者多个同类型的数组的类型定义还有很多，比如：
 
const arrC: boolean[] = [true, false]
const arrD: string[] = ['1', '3']
const arrE: void[] = [undefined, null, null]
const arrF: undefined[] = [undefined, undefined]
 
如果数组中存在不同类型的元素时，需要加个（），然后在里面加上类型定义，并且用 | 隔开就行
 
const arrG: (number | string | number[] | boolean)[] = [1, '4', true, [1, 2, 4]]
 
ts中元祖的使用：如果数组中的元素时不同类型，并且必须规定顺序，那么这样的数组应该应用中元组类型定义
 
const arrH: [string, boolean, number] = ['666', true, 666]
const arrI: [string, boolean, number][] = [['666', true, 666]]
 
数组中同类型的对象如何定义该数组呢？这种在项目里面经常用到
 
const arrJ: { one: string, two: number }[] = [
    {
        one: '666',
        two: 3
    },
    {
        one: '667',
        two: 20
    },
]
 
这样写类型定义实在是太麻烦了，ts为我们提供了类型别名的形式来代替。
 
1.数组的类型定义使用类型别名
 
type typeA = { unname: string, age: number }
const arrTypeA: typeA[] = [{ unname: '小刘', age: 24 }]
 
2.函数参数的类型定义使用类型别名
 
type typeB = { one: number, two: string }
function fntB2({ one, two }) {
    return one + two
}
const bResult2 = fntB2({ one: 1, two: '888' })
 
下一篇: typescript（六）ts中的接口

 1. 类型[ ] 
 
let arr: number[] = [1, 2, 3, 4] // 数字数组 不允许出现其他数据类型

let arr2: string[] = ['h', 'h', 'h'] // 字符串数组

let arr3: any[] = [1, 'h', 'h', 3] //允许数组中出现任意类型
 
  2. 用接口表示数组，一般用于描述类数组
 
  interface arr {

    [index: number]: number

  }

  let list: arr = [1, 2, 3, 4]
 
用接口描述数组没太大必要，但类数组不能用普通的数组的方式来描述，需要使用接口来表示类数组的形状
 
常用的类数组都有自己的接口定义，比如IArguments,NodeList,HTMLCollection
 
3.Array<elementType> 用数组泛型表示数组
 
  let arr: Array<string> = ['bonjour', 'hello']
  let arr2: Array<number> = [1, 2]
  let arr3: Array<any> = [1, 2, 'hh']