TypeScript知识

目录

number

字面量

any

unknown表示未知的类型

any和unknown的区别

类型断言 可以用来告诉编译器变量的实际类型

void函数不返回任何的值(就是不能写return)但是如果返回undefined是可以的

​never永远不会返回结果，连undefined也不返回，一般用来解决报错信息

object

箭头函数的类型限制

arry 

 元组，固定长度的数组tuple

enum枚举

类型别名

 类class

继承

super

接口

泛型

---

number

let a:number//限定a只能是number类型

let b：10//这里就有一个隐式限制，限制b只能是number类型

字面量

let c："male"|"femal"=====>这里就限定了c只能是male或者是femal

let d：boolean|string=======>这里限定d的类型只能是boolean或者是string类型的

any

any任意类型，一个变量设置成了any类型就相当于对该变量关闭了ts的类型检查，而且声明变量不指定类型，那么也是默认这个变量为any类型

let d：any=====>此时的d可以是任何类型，如number、string等

unknown表示未知的类型

let e：unknown//表示e可以是任意类型

any和unknown的区别

any可以赋值给任意变量

unknown不可以赋值给任意类型，实际上就是一个安全的any

类型断言 可以用来告诉编译器变量的实际类型

s=e as string//e是string类型

s=<string>e//e是string类型

void函数不返回任何的值(就是不能写return)但是如果返回undefined是可以的

  function  fn():void｛
  ​
  ｝

​never永远不会返回结果，连undefined也不返回，一般用来解决报错信息

​

  function    fn():never｛
  ​
  throw  n
  ​
   ｝

object

​let b:｛name:string｝//这里限制b的值只能是一个对象，而且里面只能有name这一个属性，多一个不行少一个也不行

let a:｛name:string,age？:number｝//这个就说明a可以赋值为对象，里面必须有name属性，但是age属性可有可无

let c:｛name:string,[proname:string]:any｝//这个代表着name这个属性是必须的，然后后面的代表着属性名是string然后属性值是任意类型的

c=｛name:"hggv",age:18,sex:"male"｝

箭头函数的类型限制

​(形参:类型，形参:类型……)=>返回值let d：(a：number)=>number

arry 

  ​
let   arr：string[]//表示字符串数组
let     arr1:Array\<string>//表示字符串数组

元组，固定长度的数组tuple

let   h:[string,string]//定义了一个元组，元组长度只有两个，并且都是字符串类型的，如果给数组赋值，多一个少一个都不行，必须是两个字符串

enum枚举

//定义了一个gender的枚举类
 enum   Gender｛
    male=1,
    femal=0

   ｝

 let i:{

    name:string,

    gender:Gender

    }

i=｛name:"小明",gender:Gender.male｝

类型别名

type   mytype=string//给string起一个别名mytype


let  m:mytype

类class

类主要包含两个部分:属性和方法

有static在前面的是类属性，实例对象不可调用，没有static的就是实例属性，实例对象可以调用

 class   person{

   name：string="孙悟空"//直接定义的属性是实例属性，需要创建实例对象才能访问，就像这样p.name才能获取到

   static:age:number=18//static是静态属性，属于类属性，可以直接通过访问name获得psrson.age

   readonly   gender:string="nale"//readonly开头说明这个实例属性是只读属性，不可以修改

   //定义方法

   sayhello(){

   console.log（"hello"）//这个实例方法，p.sayhello()就可以调用

   }

   }

   let p=new    person()

   
   class  dog{
   //定义属性
   name:string
   age：number
   
   //constructor构造函数，创建实例对象后调用
   constructor(name:string,age：number){
   //这里的this指的是调用类的实例对象
   this.name=name
   this.age=age
   }
   
   bark(){
   alert(this)
   }
   }
   let dog1=new   dog(name:"tony",age:18)

继承

  lass animal｛
   name:string,
   age:number,
   constructor(name,qge){
   this.name=name
   this.age=age
   }
   hello()｛
   alert("hello")
   ｝
   ｝
   
   class  dog  extends  animal｛
   //这时候相当于是CV了animal的代码给dog
   //通过继承可以将多个类中的代码提取到一个父类里面，然后子类可以写自己独有的属性和方法
   eat()｛
   alert(111)
   ｝
   ｝
   let d=new dog(name:"旺财",age:18)
   d.eat()
   d.hello()
  // 如果子类里面写了和父类一样的方法，那么子类会覆盖父类的方法，这个叫做重写

super

 class animal｛
   name:string,
   age:number,
   constructor(name,qge){
   this.name=name
   this.age=age
   }
   hello()｛
   alert("hello")
   ｝
  ｝

   class  dog  extends  animal｛
   //因为子类定义了一个新属性，同时建立实例对象的时候传了两个参数，一个是父亲的，一个是儿子的属性，而且还调用了constructor方法，就是对父类属性的重写，因此要重新调用父类的属性super()
   age:number
   constructor(name:string,age:numbee){
   super(name)
   this.age=age
   }
   //super指的是当前类的父类，也就是animal，调用了父类的方法hello
   super.hello()
   }
   let d=new dog(name:"旺财",age:18)

接口

接口用来定义 一个类的结构,用来定义一个类中应该包含哪些属性和方法，同时接口也可以当做类型声明去使用

接口还可以重复声明，相当于是后续添加，之后合并

接口中的所有属性都不能有实际的值，接口只考虑对象的结构不考虑实际值，在接口中所有的方法都是抽象方法

定义类的时候，可以使类实现一个接口，实现接口是指满足这一个类满足接口的方法，这时候使用implement关键字

 //接口
  interface  myInnterface{
      name:string,
      age:name,
      sayhello():void
  }
  ​
  //定义类
  class myClass implements myInnterface{
      name:string,
      age:number,
       constructor(name:string,age:number){
       this.name=name
       this.age=age
      }
       sayhello():void{
          console.log('hello')
      }
  }
  ​
  ​
  ​
  //对象
  const obj:myInnterface={
      name:'sss'，
      age:11
  }

泛型

在定义函数或者是类的时候，如果遇到类型不明确就可以使用泛型

  //定义了一个泛型T,类型未知,参数A的类型是T，返回值也是T,然后类型T是根据用户的输入来确定
  funnction fn<T>(a:T):T{
      return a
  }
  fn(a)//不指定泛型，ts就可以自动对类型进行推断
  fn<string>(a:'hello')//指定泛型,此时泛型T是number
  ​
  ​
  //定义了两个泛型T，K,返回类型是T
  function fn2<T,K>(a:T,b:K):T{
      return a
  }
  fn2<number,strinf>(a:123,b:'hello')
  ​
  interface inter{
      length:number
  }
  function fn3< M  extends inter>(a:T):number{
      return a.length
  }