TypeScript基础详解（后续会补充完善）

官方文档

优化编译

生成json配置文件

tsc --init

开启ts热更新生成js

tsc --watch

对于不合适的地方会报错（原本是可以编译成功的）

tsc --noEdmitOnError

降级编译，在json里面修改

"target": "es2016", 

值类型

基本类型

String
Number 没有int,float等，都是Number
Boolean
any 不进行任何类型检查

数组

:[]
:number[]
例如：
let fibonacci: number[] = [1, 1, 2, 3, 5];
:string[]
:any[]
泛型定义
:Array<number>
例如：
let fibonacci: Array<number> = [1, 1, 2, 3, 5];

类型别名

type newtype = string
type point = {
   x:number,
   y:number
}
let a:newtype = "hello"

接口

interface point {
    name: string,
    x: number,
    y: number
}
(function fun(obj: point): string {
    console.log(obj.name);
    return obj.name
})({
    name: "hello",
    x: 100,
    y: 1000
})

拓展类型

interface point {
    name: string,
    x: number,
    y: number
}
type point2 = point &{
   price:number
}

向现有的类型添加字段，注意type是不可以这样做的

interface point {
    name: string
}
interface point {
    x: number,
    y: number
}

相当于，不会覆盖，会合并

interface point {
    name: string,
    x: number,
    y: number
}

类型推断

文字类型

let sex:'男'|'女' = '男'
function fun(sex:'男'|'女'){
}

枚举

原语

函数

函数类型

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; };
推断类型
let myAdd: (x: number, y: number) => number =
    function(x, y){ return x + y; };

可选参数和可选属性
？代表可选可不选

b?: String:    表示该参数可传可不传
obj.b?.toUpperCase() 这里的？可以确保b这个参数是否传入，相当于加入一个判断

function sum(obj:{a: String, b?: String}):void {
    console.log(obj.b?.toUpperCase());
}

剩余参数
只是在原有的基础上加了类型

(function buildName(firstName: string, ...restOfName: string[]): void {
    console.log(firstName + " " + restOfName.join(" "));
})("Joseph", "Samuel", "Lucas", "MacKinzie")

this和箭头函数

泛型

定义函数

function identity(arg: any): any {
    return arg;
}

类型变量，它是一种特殊的变量，只用于表示类型而不是值。

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;
}

我们也可以把泛型变量T当做类型的一部分使用，而不是整个类型

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

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

泛型接口

interface GenericIdentityFn {
    <T>(arg: T): T;
}

泛型类

class GenericNumber<T> {
    zeroValue: T;
    add: (x: T, y: T) => T;
}

泛型还有一些属性约束，可以通过类实现接口（该接口包含该属性），从而打破约束

interface Lengthwise {
    length: number;
}
function loggingIdentity<T extends Lengthwise>(arg: T): void {
    console.log(arg.length); 
}

枚举

略

高级类型

联合类型

function fun(a:number|string){
   if(typeof a === 'number'){
       console.log('number'); 
   }else{
       console.log('string');
       
   }
}