TypeScript的数据类型：布尔，数字，字符串，数组，元组，枚举，any，void，Null和Undefined，Never，Object
声明的方式：

	布尔  		let isDone:boolean = false;
	数字      	let num:number = 6;
	字符串		let name:string = 'jerry';
	数组		let list:number[] = [1,2,3]; // 元素类型后加[]	
				let list:Array<number> = [1,2,3]  // Array<元素类型>;	
				let ro: ReadonlyArray<number> = [1,2,3]  // 只读数组
				
	元组（表示一个已知元素数量和类型的数组，各元素类型不必相同）
				let x:[string, number] = ['hello', 10];
				
	枚举		enum Color {Red=1, Green=6, Blue=4}
				let c: Color = Color.Green; // 6
				let colorName: string = Color[2]; // 'green'
				
	any			let notSure：any =  6;
				let list:any[] = [1, true, 'jerry'];
				
	void		function warn():void() { console.log('bbbb') }
				let unusable：void = undefined; // 只能为void类型赋值为undefined和null
	
	Null和Undefined 	默认情况下null和undefined是所有类型的子类型。 就是说你可以把 null和undefined赋值给number类型的变量
				let u: undefined = undefined;
				let n: null = null;

	Never		never类型表示的是那些永不存在的值的类型。 
				例如， never类型是那些总是会抛出异常或根本就不会有返回值的函数表达式或箭头函数表达式的返回值类型；
				变量也可能是 never类型，当它们被永不为真的类型保护所约束时。
				never类型是任何类型的子类型，也可以赋值给任何类型；然而，没有类型是never的子类型或可以赋值给never类型（除了never本身）
				即使 any也不可以赋值给never。
				function error(message: string): never {
				    throw new Error(message);
				}
	Object		除number，string，boolean，symbol，null或undefined之外的类型
				let obj:object = { age: 100 }
	***********************************************************************************************
	类型断言：	let someValue: any = "this is a string";
				let strLength: number = (<string>someValue).length; // 尖括号语法
				let strLength: number = (someValue as string).length; // as 语法
				

对值所具有的结构进行类型检查

interface SquareConfig {
  label: string; 
  width?: number;    // 可选属性，属性名后面加？
  readonly x: number;     // 只读属性，属性名前用readonly
  [propName: string]: any;    // 带有任意数量的其他属性
  (source: string, subString: string): boolean;    // 定义函数类型，有参数列表和返回值类型的函数定义
  [index: number]: string;    // 可索引的类型，表示当用number去索引StringArray时会得到string类型的返回值
  readonly [index: number]: string;    // 只读的索引签名
}
let myArray: StringArray;
myArray = ["Bob", "Fred"];
let myStr:string=myArray[0]

类的继承extends, class dogs extends Animal {}
公有，私有，受保护 的修饰符 public, private, protected(和私有的区别：protected在派生类中可以访问)
readonly 将属性设置为只读， 只读属性必须在声明时或构造函数里被初始化。
静态属性 static,这些属性存在于类本身上面而不是类的实例上

class Animal {
    public name1: string;
    private name2: string;
    protected name3: string;
    readonly name4: string;
    static origin = {x: 0, y: 0};  // 静态属性
    public constructor(theName: string) { this.name = theName; }
    public move(distanceInMeters: number) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
    constructor (theName: string) {
        this.name4 = theName;  // 在构造函数里初始化只读的name4
    }
    constructor(readonly name4: string) { } // 等同于上面一短代码，仅在构造函数里使用 readonly name4: string参数来创建和初始化 name4成员。 
    // 把声明和赋值合并至一处。public和protexted可以同样使用
}

抽象类
abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。抽象类做为其它派生类的基类使用。

abstract class Animal {
    abstract makeSound(): void;
    abstract printMeeting(): void; // 必须在派生类中实现
    constructor(public name: string) {  }
}

class dogsextends Animal  {
    constructor() {
        super('Accounting and Auditing'); // 在派生类的构造函数中必须调用 super()
    }
    printMeeting(): void { // 实现抽象类里的抽象方法
        console.log('The Accounting Department meets each Monday at 10am.');
    }
}
// 象类中的抽象方法不包含具体实现并且必须在派生类中实现

返回值的类型与传入参数的类型是相同的

function identity<T>(arg: T): T {
    return arg;
}

function loggingIdentity<T>(arg: T[]): T[] {
    console.log(arg.length);  // Array has a .length, so no more error
    return arg;
}
===
function loggingIdentity<T>(arg: Array<T>): Array<T> {
    console.log(arg.length);  // Array has a .length, so no more error
    return arg;
}

// 泛型接口
interface GenericIdentityFn<T> {
    (arg: T): T;
}
泛型类
class GenericNumber<T> {
    zeroValue: T;
    add: (x: T, y: T) => T;
}
let myGenericNumber = new GenericNumber<number>();

类型断言是将变量或表达式的类型强制转换为开发者指定的类型的方式
语法 ：值 as 类型 或者<类型>值 （在tsx中必须使用as）

var foo = <foo>bar;
var foo = bar as foo;

每天学习一点点。。。。。从入门到熟练（放弃）。。。。