数组与元组
创建一个数组很简单：
代码语言：javascript复制const arr = [1];此时 TypeScript 将会推断 arr 类型为 number[]：
arr.push('1'); // Error当数组元素具有其它类型时，可以通过类型注解的方式：
代码语言：javascript复制const arr: Array<string | number> = [1];
arr.push('1'); // OK
arr.push(true); // Error或者你也可以通过可选元组的方式：
代码语言：javascript复制const arr: [number, string?] = [1]; // arr 的成员类型可以是: number, string, undefined
arr.push('1'); // OK
arr.push(true); // Error使用元组形式，还能提供指定位置的类型检查：
代码语言：javascript复制arr[0] = '1'; // Error
arr[1] = 1; // Error使用
通常，我们使用 Promise.all 并行发出多个请求：
interface A {
name: string;
}
interface B {
age: number;
}
const [{ data: a }, { data: b }] = await Promise.all([
axios.get<A>('http://some.1'),
axios.get<B>('http://some.2')
])此时，TypeScript 能推出 a 的类型是 A, b 的类型是 B。
现在，稍作改变：当满足特定条件时，才发出第二个请求：
代码语言：javascript复制// 使用类型注解
const requestList: [Promise<AxiosResponse<A>>, Promise<AxiosResponse<B>>?]
= [axios.get<A>('http://some.1')];
if (flag) {
requestList[1] = (axios.get<B>('http://some.2'));
};
const [ { data: a }, response ] = await Promise.all(requestList);我们期望它会如预想时那样工作，可是事与愿违，Promise.all(requestList)，会出现类型兼容性的报错，在这个 Issues 里，描述了相同的问题。
现在，你可以通过断言的方式，来让程序正常运作：
代码语言：javascript复制const requestList: any[] = [axios.get<A>('http://some.1')]; // 设置为 any[] 类型
if (flag) {
requestList[1] = (axios.get<B>('http://some.2'));
}
const [
{ data: a },
response
] = await Promise.all(requestList) as [AxiosResponse<A>, AxiosResponse<B>?] // 类型安全字面量类型
在 JavaScript 基础上，TypeScript 扩展了一系列字面量类型，用来确保类型的准确性。
如创建一个字符串字面量：
代码语言：javascript复制const a = 'hello'; // a 的类型是 'hello'
a = 'world'; // Error或者你也可以：
代码语言：javascript复制let a: 'hello' = 'hello'; // a 的类型是 'hello'
a = 'world'; // Error其它数据类型与此相似。
你也可以定义交叉类型与联合类型的字面量：
代码语言：javascript复制interface A {
name: string;
}
interface B {
name: string;
age: number;
}
type C = A | B;
type D = A & B;对象字面量类型
对于对象字面量的类型，TypeScript 有一个被称之为 「Freshness 」的概念，它也被称为更严格的对象字面量检查，如下例子：
代码语言：javascript复制let someThing: { name: string };
someThing = { name: 'hello' }; // ok
someThing = { name: 'hello', age: 123 }; // Error, 对象字面量只能指定已知属性, { name: string } 类型中不存在 age 属性
let otherThing = { name: 'hello', age: 123 };
someThing = otherThing; // okTypeScript 认为创建的每个对象字面量都是 「 fresh 」 状态；当一个 「 fresh 」 对象字面量赋值给一个变量时，如果对象的类型与变量类型不兼容时，会出现报错（如上例子中 someThine = { name: 'hello', age: 123 }; 的错误）；当对象字面量的类型变宽，对象字面量的 「 fresh 」 状态会消失（如上例子中 someThing = otherThing; ，赋值以后，someThing 的类型变宽）。
一个更实际的用例如下：
代码语言：javascript复制function logName(something: { name: string }) {
console.log(something.name);
}
const obj = {
name: 'matt',
job: 'being awesome'
}
logName(obj); // ok
logName({ name: 'matt' }); // ok
logName({ nama: 'matt' }); // Error: nama 属性在 { name: string } 属性中不存在。
logName({ name: 'matt', job: 'being awesome' }); // Error: 对象字面量只能指定已知属性，`job` 属性在这里并不存在。基本原理与上文中相似，当想用更严格的类型检查时，可以传一个具有 fresh 状态的对象字面量（如 logName({ name: 'matt', job: 'being awesome' });）。当你想多传一些属性至函数，可以将对象字面量赋值至一个新变量，然后再传至函数（如 logName(obj)）。或者你也可以通过给函数形参添加多余类型的方式 function logName(someThing: { name: string; [key: string]: string })。
