TypeScript

变量类型

:string
:number
:void
:never

函数对象多个参数

function add({ one, two }: { one: number, two: number }): number {
  return one + two;
}
const three = add({ one: 1, two: 2 });

函数对象单个参数

function getNumber({ one }: { one: number }): number {
  return one;
}
const one = getNumber({ one: 1 });

定义不同类型的数组

const arr1: (number | string)[] = [1, 'string', 2]

类型别名

type Lday = { name: string; age: number }
const XiaoGeGe1: Lday[] = [
  { name: '刘英', age: 20 },
  { name: '丛继永', age: 22 }
]

用类定义,类型别名

class Madam {
  name: string
  age: number
}
const xiaogege: Madam[] = [
  { name: '丛继永', age: 12 },
  { name: '前端', age: 20 }
]

元组和数组一样，就是可以限定每个元素的类型
接口和类型别名一样，接口必须是对象
?非必须的值

interface Girl {
  name: string;
  age: number;
  bust: number;
  waistline?: number; //问号可能表示值可以省略不写
}
const getResume = (girl: Girl) => {
  console.log(girl.name + "年龄是：" + girl.age);
  console.log(girl.name + "胸围是：" + girl.bust);
};

**允许加入任意值 ，属性和值 **

interface Girl {
  name: string;
  [propname: string]: any;
}

接口里面也可以放方法

interface Girl {
  name: string;
  [propname: string]: any;
  say(): string;
}

class XiaoJieJie implements Girl {
  name = "刘英";
  age = 18;
  bust = 90;
  say() {
    return "欢迎光临 ，红浪漫洗浴！！";
  }
}

类可以继承重写
public从英文字面的解释就是公共的或者说是公众的，在程序里的意思就是允许在类的内部和外部被调用.

class Person {
//内部
    public name:string;
    public sayHello(){
        console.log(this.name + ' say Hello')
    }
}
//-------以下属于类的外部--------
const person = new Person()
person.name = 'jspang.com'
person.sayHello()
console.log(person.name)

private 访问属性的意思是，只允许再类的内部被调用，外部不允许调用
protected 允许在类内及继承的子类中使用

类的构造函数
构造函数就是在类被初始化的时候，自动执行的一个方法。
普通写法(好理解)

class Person{
    public name :string ;
    constructor(name:string){
        this.name=name
    }

}

const person= new Person('jspang')
console.log(person.name)

开发简单写法

class Person{
    constructor(public name:string){
    }
}
const person= new Person('jspang')
console.log(person.name)

在子类中使用构造函数需要用super()调用父类的构造函数

class Person1{
  constructor(public name:string){}
}

class Teacher extends Person1{
  constructor(public age:number){
      super('jspang')
  }
}

const teacher = new Teacher(18)
console.log(teacher.age)
console.log(teacher.name)

private 封闭一个属性
使用类的Getter和Setter设置和获取
getter属性的关键字是get,后边跟着类似方法的东西,但是你要注意，它并不是方法，归根到底还是属性。

//声明一个XiaoJieJie（小姐姐）类，都知道小姐姐的年龄是不能随便告诉人，所以使用了private,这样别人就都不知道她的真实年龄，而只有她自己知道。如果别人想知道，就必须通过getter属性知道,注意我这里用的是属性，对他就是一个属性
class Xiaojiejie {
  constructor(private _age:number){}
  get age(){
      return this._age
  }
}
const dajiao = new Xiaojiejie(28)
console.log(dajiao.getAge)

在getter里，我们可以对_age进行处理，比如别人问的时候我们就偷摸的减少 10 岁。代码可以写成这样

class Xiaojiejie {
  constructor(private _age:number){}
  get age(){
      return this._age-10
  }
}

age是私有的，那类的外部就没办法改变，所以这时候可以用setter属性进行改变

class Xiaojiejie {
  constructor(private _age:number){}
  get age(){
      return this._age-10
  }
  set age(age:number){
    this._age=age
  }
}

const dajiao = new Xiaojiejie(28)
dajiao.age=25
console.log(dajiao.age)

其实setter也是可以保护私有变量的，现在大脚的年龄输出是 15 岁，这肯定不行，不符合法律哦，这样是我们在setter里给他加上个 3 岁，就可以了。

 set age(age:number){
    this._age=age+3
  }

用static声明的属性和方法，不需要进行声明对象，就可以直接使用，代码如下。

class Girl {
  static sayLove() {
    return "I Love you";
  }
}
console.log(Girl.sayLove());

readonly,也就是只读的意思，在实例化对象时赋予的名字，以后不能再更改了

class Person {
    public readonly _name :string;
    constructor(name:string ){
        this._name = name;
    }
}

const person = new Person('jspang')
person._name= '谢广坤' //不可以修改，vscode会报错
console.log(person._name)

抽象类

abstract class Girl {
  abstract skill():void
}

class Waiter extends Girl {
  skill() {
    console.log('大爷，请喝水！')
  }
}
class BaseTeacher extends Girl {
  skill() {
    console.log('大爷，来个泰式按摩吧！')
  }
}
class seniorTeacher extends Girl {
 skill() {
    console.log('大爷，来个SPA全身按摩吧！')
  }
}
var a = new seniorTeacher
a.skill()

联合类型animal(任意值)
联合类型，可以认为一个变量可能有两种或两种以上的类型

interface Waiter {
  anjiao: boolean;
  say: () => {};
}

interface Teacher {
  anjiao: boolean;
  skill: () => {};
}

function judgeWho(animal: Waiter | Teacher) {}