ts

1.安装与编译

npm install -g typescript

tsc helloworld.ts

2.数据类型

注：ts中定义变量必须指定类型，若不是any类型，后续重新赋值时改变类型则会报错

var flag:boolean=true
var num:number=1
var str:string="123"

// 数组定义的几种方式
var arr:number[]=[1,2,3]  // 数组中的元素都为数字类型
var arr:Array<number>=[1,2,3]  // 数组中的元素都为数字类型
var arr:[number,string]=[1,"1"]  // 为数组中指定位置的元素指定类型
var arr:any=[1,"1",false]  // 数组中元素为任意类型

枚举类型(enum)

enum Err {'undefined'=-1,null=-2,success=1}
var e:Err=Err.success
console.log(e) // 1

任意类型

var a:any=1
a="1" // 当指定为任意类型时，后续可赋值为任意类型

undefined和null

var a:undefined // 定义未赋值时  可定义为undefined
var a:number | undefined | null // 定义为数字或undefined或null

var a:null
a=null // 定义为空时，赋值null

void类型

// 方法没有返回值
function a():void{
  console.log("a")
}

函数

// 指定参数类型和返回值类型
functin info(name:string, age:number):string {
  return "字符串"
}
// 没有返回值的方法
functin info():void {
  console.log('没有return')
}
// 可选参数
functin info(name:string, age?:number):string {  // age可传可不传，可选参数必须放在后面
  return "字符串"
}
// 默认参数
functin info(name:string, age:number=20):string {  // age不传时默认为20
  return "字符串"
}

类和继承

1.类的实现

class Person{
  public name: string
  constructor (n:string) {
    this.name = n
  }
  run():viod {
    cosnole.log("run")
  }
}

//等价于
function Person(name) {
  this.name = name
  this.run = function() {
    cosnole.log("run")
  }
}

2.继承 （extends、super）// 子类和父类有相同方法时 调用子类方法

class Web extends Person {
  constructor (name:string) {
    super(name)
  }
}
var w=new Web('张三')
w.run()

3.类的修饰符

public:公有类型 在类、子类、类外面都可以访问
protected:保护类型 在类、子类可以访问
private:私有类型 只能在子类使用

4.实例方法和静态方法

class Person{
  public name: string
  static age=20
  constructor (n:string) {
    this.name = n
  }
  run1():viod {    // 实例方法
    cosnole.log("run1")
  }
  static run2():viod {    // 静态方法
    cosnole.log("run2"+Person.age )    // 静态方法中调用静态属性
  }
}
var a=new Person('aa')
a.run1()  // 实例方法调用

Person.run2() // 静态方法调用

4.抽象方法

abstract class Person{
  public name: string
  static age=20
  constructor (n:string) {
    this.name = n;
  }
  run1():viod {    // 实例方法
    cosnole.log("run1")
  }
  abstract run2():any;  // 抽象方法必须放在抽象类中，且在继承类中具体实现
}

5.1函数类型接口

// 传入参数类型和返回类型必须与定义类型一致
interface encrypt{ // 定义函数接口
  (key:string,value:string):String
}
var md5:encrypt = function(key:string,value:string):string{
  return key+value
}

5.2索引类型接口

// 传入参数类型和返回类型必须与定义类型一致
interace userArr = {
  [index:number]:string
}
var arr:userArr=['aaa','bbb']

5.3类类型接口

// 定义类实现接口类型
interface Animal {
  name: string;
  eat(str:string):void
}
class Dog implements Animal{ //dog类实现Animal接口
  name:string;
  constructor(name:string){
    this.name=name
  }
  eat(){
    console.log(this.name)
  }
}

6.接口继承

interface Animal { // 定义类接口
  eat():viod;
}
interface Person extends Animal {  // 接口Person继承Animal
  work():viod;
}
class web implements Person{ //dog类实现Person接口和Animal接口
  name:string;
  constructor(name:string){
    this.name=name
  }
  eat(){
    console.log(this.name)
  }
  work(){
    console.log(this.name)
  }
}

7.泛型

7.1 范型类

class Minclas<T> {
  public list:T[] = [];
  add(value:T):void{
    this.list.push(value)
  }
  min():T{
    var min = this.list[0];
    for(var i=0; i< this.list.length;i++){
      if(min > this.list[i]){
        min = this.list[i]
      }
    }
    return min
  }
}
var m = new Minclas<number>() // 实例化类，并指定T的类型是number

7.2 范型接口

interface configFn{
  <T>(value:T):T;
}
var getData:configFn=function<T>(value:T):T{
  return value;
}
getData<string>('aaa') // 实例化接口，并指定传入参数类型是字符串