TypeScript学习笔记

类型：

number 数字

string 字符串

boolean 布尔

any 用于声明任意类型 any类型赋值给别的变量会关闭ts类型的检测

unknown 安全的any 未知类型

unknown类型赋值给别的变量会有检测，不能直接赋值

void 空值

never 没有值，不能是任何值

object 任意js对象

array 任意js数组

tuple 元素，ts新增类型，固定长度数组

enum 枚举，ts新增类型例：

enum{A,B}

赋值：字面量

let a : 10; 定义的变量不能更改

let b : “man” | “woman”; 变量只能赋值为man 或 woman

不建议使用any

let c : any; 任意类型 ##### 可以赋值为认可类型或者说是ts的类型检测。

let c; 不指定类型 就是隐藏式的any。 （一定要避免）

any 用于声明任意类型 any类型赋值给别的变量会关闭ts类型的检测

unknown 安全的any 未知类型

unknown类型赋值给别的变量会有检测，不能直接赋值

类型断言:告诉解析器变量的实际类型

s = e as string;  或  s = <string> e;

函数没有返回值：

1.

function fun():void{}  

void表示为空，没有返回值的函数（可以为null,或者undefined）

2.

function fun():never{   never永远没有返回值  
    throw new Error("出错了");
}

object一般不用因为js里边基本上都是变量。

let b : {name: string};   赋值的时候要与结构一样
let b : {name: string, age?:number};   ?代表age可有可无
let b : {name: string,[propName : string]:any};

表示有一个name属性，其他的可有可无，也可多写。

定义函数的结构：

let b:(a:number,b:number)=>number; 参数为number 返回值也为number
function b(a,b){}

数组: 两种写法

let a : string[];  字符串类型数组
let g : Array<number>; 数字类型的数组

元组：

let h : [string,string]; 数组元素长度为2只能式字符串

enum : 可以简单明了的看到或者，几个值之间选择的。

enum Gender{
    Male = 0;
    Female = 1
}
let i : {name:string,gender:Gender};
i={
    name : '孙悟空',
    gender : Gender.Male
}

类型别名: 定义一个可以复用的类型。

type mytype = 1 | 2 | 3;  
let a : mytype;
let b : mytype;

函数参数类型声明：

function fun(a:number,b:number){}

函数返回值类型声明：

function fun(a:number):number{}  意思是返回值类型为数字

面向对象

class Person {
    name: string = '默认';
    say() {
        consol.log(this.name)
    }
    
}
let funa: object = new Person()
funa.name = '马彪';
funa.say();

构造方法

constror(name: string){
    this.name = name
} 

静态属性 静态方法

只能通过类名掉

Person.test()
static des: string = '静态属性'
static test() {
    consol.log('静态方法')
}

继承

class Perrson{
    name: string = '';
    say(){
        console.log('名字'+this.name)
    }
}
class Student extends Person{
    say(){
        super.say()
        console.log('子类'+this.name)
    }
}
let a = new Student()
a.name = '马彪';
a.say()

抽象类

本身无法实例化，只能用于继承

抽象方法在子类中，要声明

absstract class Person{
    run (){} 
    absstract say()
}
class Student extends Person{
    say(){}
}
let a: Person = new Student()

接口

弥补多继承

interface IWoif{
    attack()
}
interface IDog(){
    eat()
}
class WolfMan extends Person implements IWoif, IDog{
    attack(){}
    eat(){}
}

属性寄存器

class Person{
    _hp: number = 100;
    get hp(){
        return this._hp
    }
    set hp(val){
        this._hp = val > 0 ? cal : 0;
    }
}

名称空间

多人开发
mnamespace Mb{
    export class Person{}
}
let a = new Mb.Person()

泛型

多类型最后使用泛型

function add<T>(num: T): T{
    return T + T
}
add<number>(3)

元祖

一般用作为函数返回值

数组

访问修饰符

1、public: 公开的，默认 任何对象在任何地方都可以进行访问

2、private： 私有的， 只能在当前类中进行访问

3、 protected： 受保护的，这能在当前类或者子类中进行访问