TS学习
1. 基础类型：number、string、Boolean、null、undefined、Array、Tuple、void、Never、enum、Any、
（1）元组 Tuple：表示一个已知元素数量和类型的数组，各个元素类型可以不同。可以push，不能跨界访问和取值。
2.类
（1）当成员被标记成 private时，它就不能在声明它的类的外部访问
（2）构造函数也可以被标记成 protected。 这意味着这个类不能在包含它的类外被实例化，但是能被继承。
（3）抽象类
抽象类做为其它派生类的基类使用。 它们一般不会直接被实例化。 不同于接口，抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。
3.枚举
TypeScript支持数字的和基于字符串的枚举。
4.泛型
组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型。
(1)泛型接口
定义公共接口和传入参数的类型（参数的类型，编译器自己判断）
interface Identities {
value: V,
message: M
}
function identity(value: T, message: U): Identities {
console.log("T:", value,":",typeof value);
console.log("U:", message,":",typeof message);
let identities: Identities = {
value,
message
}
return identities
}
console.log(identity(true, "hello,world"))
（2）泛型类
泛型类可确保在整个类中一致地使用指定的数据类型.
interface Identities {
value: T,
getIdentity: () => T
}
class IdentityClass implements Identities {
value: T
constructor(value: T) {
this.value = value
}
getIdentity(): T {
return this.value
}
}
let idClass = new IdentityClass("aaa")
console.log(idClass.getIdentity()) //aaa
let idClass2 = new IdentityClass(68)
console.log(idClass.getIdentity()) //68, 编译会根据传入的值判断其类型
5. 类型别名
类型别名就是给一种类型起个别的名字，之后只要使用这个类型的地方，都可以用这个名字作为类型代替。它只是起了一个名字，并不是创建了一个新类型。使用type关键字。
(1) 使用type关键字
type StringType = string
let s:StringType
s = "hello";
s = 123 //error
(2)类型别名可用于使用泛型
type PositionType = { x: T, y: T }
let p1: PositionType = {
x: 3,
y: 5
}
let p2: PositionType = {
x: 'right',
y: 'top'
}
(3)使用类型别名时也可以在属性中引用自己：
type Next = {
val: T,
next?: Next // 这里属性引用类型别名自身
}
let list: Next = {
val: 'first',
next: {
val: 'second',
next: {
val: 'third',
next: 'test' // 这里不符合类型别名规定，导致最外层 next 报错
}
}
}
6.模块 的导出和导入
(1)先声明再导出
//导出： test1.ts
class Earth{
name: string = 'earth';
rotation(){
let oneday: string = 'A rotation takes 24 hours.';
console.log(oneday);
}
}
let human: string = 'Human being lives on Earth.';
//导入
import {Earth, human} from "./test1.ts"
let ourEarth: Earth = new Earth();
(2)在声明时导出
//导出： test1.ts
export class Mars{
name: string = 'Mars';
status: string = 'China will explore Mars in the following several decades.';
}
export function exploring(){
console.log('Launching Changzheng-5 rocket.');
console.log('Add oil, 胖五.')；
}
//导入
import {Mars, exploring} from './test1.ts'
(3) 默认的导出导入
// Jupiter.ts
class Jupiter{
name: string = 'Jupiter';
feature: string = 'very very big.';
}
let jupiterStatus: string = 'Jupiter is absorbing material from the sun.';
export default {Jupiter, jupiterStatus};
//导入
import SpectacularJupiter from './Jupiter'; // 这里SpectacularJupiter相当于Jupiter和jupiterStatus的集合体
let beautifulJupiter = new SpectacularJupiter.Jupiter();
console.log('NASA report: ' + beautifulJupiter.name + ' is ' + beautifulJupiter.feature);
console.log(SpectacularJupiter.jupiterStatus);
(4)常见的导出语句
// 普通导出
export {something1, something2, ..., somethingN};
export {something1 as rename1, something2 as rename2, ..., somethingN as renameN};
export let something = '100';
export function func(){/* some actions here */};
// 默认导出
export default something;
export default {something1, something2, ..., somethingN};
export default let something = '100';
export default function func(){/* some actions here */};
// 重新导出
export {something1, something2, ..., somethingN} from 'modulename';
export {something1 as rename1, something2 as rename2, ..., somethingN as renameN} from 'modulename';
export * from 'modulename'; //可以作为中间ts
// 兼容CommonJS和AMD的导出
export = {something1, something2, ..., somethingN};
export = something;
（5）常见的导入语句
// 普通导入
import {something1, something2, ..., somethingN} from 'modulename';
import {something1 as rename1, something2 as rename2, ..., somethingN as renameN} from 'modulename';
// 默认导入
import theNewModuleNameYouLike from 'modulename';
// 导入全部
import * as theNameYouLike from 'modulename';
// 兼容CommonJS和AMD的导入
import theNewModuleNameYouLike = require('modulename');