typescript

ts

基础类型： 
布尔值 let isDone:boolean = false
数字 let decNumber:number = 2
字符串 let name:string = `abc`
数组 let array:number[] = [1,2,3] ||
	 let array:string[] = [`1`,`2`,`3`] || 
	 let list:Array<number> = [1,2,3]||
数组泛型	 let list:Array<string> = [`1`,`2`]

元组 let x:[string,number] x= ['abc',100]
枚举 enum Color { Red = 1,Green='#eee',Blue }
	let colorName:string = Color[2] // Green 值引用
	let c:Color = Color.Red // 属性引用
任意类型 let notSure:any= 4 || notSure = `abc` || notSure = false
没有类型 void function test():void{

		}
		let msg:void  = undefined || null // 无用
undefined null 默认是所有类型的子类型 都可以赋值为这两个


永远不存在的类型 Never function error(msg:string):never{
	throw new Error(msg)
} 

Object declare function create(o:Object|null):void;
create({prop:0})

类型断言 
		尖括号  let msg:any = `abc`; let strLen:number=(<string>msg).length
		as 语法 let sttLen:number=(msg as string).length  

q1：数组泛型和数组的区别
--strictNullChecks标记
联合类型
ts 遍历对象、数组

变量声明
var  闭包 setTimeout(立即执行函数)
let 作用域
const
解构数组 一一对应 let [f0,f1] = [1,2]  一对多 let [f0,...rest] = [1,2,3,4] // reset = [2,3,4] 
解构对象 let {a,b} = o  let {a,...reset} = o // reset.b reset.c 
		 let { a:newName,b:newName2} = o  // 重命名
解构函数声明 type C = {a:string ,b:number}
function f({a,b}:C):void{

}
与解构相反的是 展开 // TypeScript编译器不允许展开泛型函数上的类型参数

接口对象 interface
	 interface data {
	 	name:string; // 必填
	 	age?:number; // 可选
	 	readonly height:number;
	 	[propName: string]: any;
	 }

接口函数
	interface SearchFunc{
	  (name:string,age:number):booloean
	}

	let mySeach:SearchFunc;
	mySeach = function(name:string,age:number):booloean{
		let s = name.search(age);
		return result > -1
	}
	interface StringArray{
		[index:number]:string // 下标为number的索引 返回string
	}
	let mArray:StringArray;
	mArray = ['q','e']
	let mStr:string = mArray[0]

接口继承 
	interface Shap {
		color:string;
	}
	interface Per extends shap{
		 sideLength: number;
	}
	let sq = <Per>{};
	sq.color = 'abc'
	sq.sideLength = 12

ReadonlyArray<T>类型 //数组创建后不可改变
	 let a:number[] = [1,2]
	 let ra:ReadonlyArray<number> = a
	 ra[0] // 只读 不能push length 赋值给自己或他人
	 a = ra as number[] // 断言
	 使用：做为变量使用的话用 const，若做为属性则使用readonly。

类
	class person{
		static origin = {x: 0, y: 0};
		protected width: string; // 我们不能在 Person类外使用 name ,但是我们仍然可以通过 Employee类的实例方法访问，因为 Employee是由 Person派生而来的
		readonly numberOfLegs: number = 8; // 读属性必须在声明时或构造函数里被初始化
		public  name:string;
		private  age:number;
		public  constructor(msg:string){
			this.name = msg;
		}
		public  greet(){
			return 'hello ,'+this.name
		}
	}
	let msg = new person('hzy')

存取器 getters/setters  get set

抽象类 // 抽象方法不包含具体实现并且必须在派生类中实现
		// 在派生类的构造函数中必须调用 super()
		// 允许创建一个对抽象类型的引用
		// 允许对一个抽象子类进行实例化和赋值
 		abstract class Person{
		 	abstract makeSound(): void;
		    move(): void {
		        console.log('roaming the earch...');
		    }
		}

高级技巧
构造函数
class Greeter{

}
let greeterMaker: typeof Greeter = Greeter; // 类型别名 typeof

函数
函数类型
function add(x: number, y: number): number {
    return x + y;
}

let myAdd = function(x: number, y: number): number { return x + y; };

书写完整函数类型
	let myAdd: (x: number, y: number) => number =
    function(x: number, y: number): number { return x + y; };

推断类型