Typescript 2+迷你书 ：从入门到不放弃

// 最简单的一个声明, 在需要推导的后面加上冒号和类型
let a: number;  

/*但是有些人有强迫症的，比如会出现这类的写法，但是这类写法在最新版
*中会变成一个警告，说是该类型没必要再写推导类型了，建议移除；
*/
let b: number = 0; // 会出现警告,应该改成下面这个
let c: boolean = false;

let b = 0; // 推荐的写法;
let c = false;

//--------------- 在TS中类型会比JS稍微多一些,记得ts中类型全部是小写---------------//

let temp1: number; // 二进制，八进制，浮点，整数皆归这类
let temp2: string; // 字符串类型，ES6的模板字符串也属于这货
let temp3_1: number[]; // 代表返回值均为数字的数组
let temp3_2: Array<any>; // 数组泛型，代表数组内可以包含所有类型
let temp3_3: [string,number,boolean]; 元组数组，子元素的类型强制一一对应
let temp4: any; // any代表任意类型都可以，万金油
let temp5: void;  // 只能赋值undefined或者null
let temp6: undefined; // 只能赋值undefined,在--strictNullChecks模式下只能赋值给: void
let temp7: null; // 只能赋值null,在--strictNullChecks模式下只能赋值给: void
let temp8: object; // 类似Object.create的皆可以

//------ 特殊类型
// 对于异常这类的永远得不到正确返回值的，使用: never
try{
 ...
}catch(e): never{
    ...
}

// 不需要推断的--- 类型断言，简言之，我不需要ts推导，本来就知道这货是什么
// 最常见的是用于引入一些第三方的js库的时候，比如echarts的作用域必须全局window
const echarts = (<any>window)['echarts'];

export interface Personal{
    name: string; 
    age: number;
    sex: string;
    colthColor?: string[]; // 衣服颜色,[?]可选参数，返回字符串数组
    readonly idCard: number | string; 
    /* readonly是新版本加进来的，和const大同小异，
    *两者区分readonly用于接口声明而const能作用于变量， 
    *后面number | string其实另外一部分的内容点，叫做联合推导，就是值可以是数字或者字符串
    */
    // 接口也能描述函数参数这些，写法都差不多
}

//------使用,比如用于接口上传 ----- 记得导入
// 接口内的字段及类型会强制对应，不然会报错，这会让代码更加严谨；
uploadUserInfo( personalParam: Personal ): Observable<any> {
    return this.authHttp.upload( environment.baseUrl + 'xxxx/UpdateInfo', personalParam );
}

// 接口也可以用实现某些方法，和C#或Java里接口的基本作用一样
// 关键字implements
export class MitUpdateUserInfo implements  Personal{
 ...
}

// 接口与接口之间可以实现单继承或者多继承
// 关键字extends
interface extraParam{
    favority:any
}

interface Personal extends extraParam{
    ....
}

export class test{
    public a: number; // 在类直接声明的作用域整个类内，默认为public，写不写看自己了
    constructor(){
        // 构造函数，构造函数必须可以带上什么范围
        // public,private,protected
    }

    test(){
        函数。。。。
    }
}

/** 修饰符：更细致的解释请看官方文档手册
* public : 默认，公共开放
* private: 自身类使用
* protected : 派生类可以使用【子类这类】
* readonly : 只读
*/


// 同理类也是必然可以继承的，但是不能多继承，不能多继承，不能多继承
// 依旧关键字是extends
export class test1{
    constructor(private hh:string){
        this.hh = hh;
    }

    test(a){
        console.log(this.hh + a);
    }

}

export class test2 extend test1{
    public a = 'sfasdf';
    constructor(a:string){
        super(a);
    }

    test(){
        super.test(); // 继承方法
    }
}


// 当然，类中不可能少了抽象类，这货的作用就是让一堆人继承实现它带的东西
export abstract class test3 {
  constructor(public name: string) {

  }

  eat(): void {
    console.log(this.name + '吃吃吃');
    // 可以在抽象内实现默认方法，然后子类复写或者直接用
  }

  abstract move(): void;  // 等着子类来实现动的方法
}

// 也有set和get，就是getter和setter

exrpot class test4{
    constructor(){}

    sun(leaf:string,drink?:boolean):void{
        ...
        // 传入的参数leaf为字符串类型，该方法没有任何返回
        // 水为可选参数，传入为布尔类型
    }
}

// 应该有人想问this，但是this的范围该怎么样就怎么样，在被调用的上下文中确定
//适量的使用箭头函数会让你写起来更舒服复制代码

// TS中的泛型只能用于接口，类(实例)，不能用于枚举和命名空间
// 泛型用符号T表示，不一定要用<T>的写法
identity<T>(arg: T): T {
    return arg;
}

// 这里拿官方的文档例子就很清晰了。。
enum Enum {
    A
}
let a = Enum.A;
let nameOfA = Enum[Enum.A]; // "A"

test(args1: A,args2: B ): A & B{
   ...
}复制代码

let a: number | string | null;  // 即a可以赋值为这三种类型的任意一种

declare var System: any;
declare var $: any;
declare var jQuery: any;
declare var _: any;
declare var echarts: any;
declare var BMap: any;
declare var BMapLib: any;

// 从组件中导入AppComponent这个类
import { AppComponent } from './app.component'; 

// 导入所有内部可以导出的
import * from './app.routes';

// 导入某个功能并且把它别名化(alias)
import { MitNotificationsModule as notify } from './widgets/mit-notifications/mit-notifications.module';

// 导入两个功能(成员)
import { UserAdd , UserDelte } from "User.module"; 

// 上面两个的结合
import { UserAdd , UserDelte as d } from "User.module"; 

// 导入默认成员及成员
import defaultMember, { UserAdd  } from "User.module"; 

// 导入默认成员且重命名
import defaultMember, * as name from "module-name"; 

// 导入整个模块，慎重使用，尽量导入一些你需要用到的，避免这种，有可能你们有部分代码会影响全局
import "global.module";


//------- 说了导入，那么顺便扯扯导出把
// 导出的花样也挺多，下至变量常量，上至对象函数
// 比较有差异的就是default 。。 其他的和上面大致对应
export default const name = 'crper'; // 默认成员，一个模块只有一个至多一个默认
export { a , b} // 导出a,b
....