nestjs相关 - 《前端技术》

什么是面向对象
- 面向对象编程
依赖注入
Nestjs 概览
puppeteer回放工具

什么是面向对象

一切皆对象
封装、继承、多态

class Person{
    protected string name;
    protected Person(string name) {
        this.name = name;
    }
    public void eat()
    {
        System.out.println(this.name+"吃饭!");
    }
    public void work()
    {
        System.out.println(this.name+"工作!");
    }
    public void sleep()
    {
        System.out.println(this.name+"睡觉!");
    }
}
class Rd extends Person{
    public Rd(string name){
        super(name)
    }
    public void work(){
        System.out.println(this.name+"写代码!");
    }
}
class Pm extends Person{
    public Pm(string name,string age){
        super(name,age)
    }
    public void work(){
        System.out.println(this.name+"写需求!");
    }
}
Person person = new Pm('A')
person.eat();//A吃饭
person.work();//A写需求
person.sleep();//A睡觉

把大象放进冰箱(假设大象很乖，冰箱很大，门能关住)

面向对象编程

🐘 = {}
📦 = new Class(){
    open(){}
    put(🐘){}
    close(){}
}
📦.open()
📦.put(🐘)
📦.close()

面向过程编程

struct 🐘+📦
openDoor(📦){}
putElephant(🐘){}
closeDoor(){📦}

依赖注入

网上例子

小明有三大逛知乎、玩王者农药、抢微信红包

nestjs相关 - 图1

想做这些事，他必须依赖一部手机，所以他买了一台 iphone6，接下来我们来制造一个 iphone6：

class iPhone6 extends Iphone
{
    function read(person="某人"){
        //"打开了知乎然后编了一个故事";
    }
    function play(person="某人"){
        //"打开了王者农药并送起了人头";
    }
    function grab(person="某人")
    {
        //"开始抢红包却只抢不发 \n";
    }
}

然后小王就可以-》逛知乎、玩王者农药、抢微信红包：

class Ming extends Person
{
    private name;
    function read(){
        (new iPhone6())->read(this.name);//逛知乎
    }
    function  play(){
        (new iPhone6())->play(this.name);//玩农药
    }
    function  grab(){
        (new iPhone6())->grab(this.name);//抢红包
    }
}
$ming = new Ming();  //小明起床
$ming->read(); //小明打开了知乎然后编了一个故事
$ming->play(); //小明打开了王者农药并送起了人头
$ming->grab(); //小明开始抢红包却只抢不发

经历了漫长的抢红包，小明终于把有钱把 iphone6 换成了二手的 iphoneX 了，要想使用，小明必须经过一番改造：
nestjs相关 - 图2


class iphoneX extends Iphone{
    //省略...
}
class Ming extends Person
{
    private name;
    function read(){
        (new iphoneX())->read(this.name);//逛知乎
    }
    function  play(){
        (new iphoneX())->play(this.name);//玩农药
    }
    function  grab(){
        (new iphoneX())->grab(this.name);//抢红包
    }
}

这样显然不好，如果后面在换一个 iPhone13，又要经过一次改造：

class Ming extends Person
{
    private name;
    private phone; //将手机作为自己的成员变量
    construct($phone)
    {
        this._name = '小明';
        this.phone = $phone;
    }
    function read()
    {
        this.phone->read(this.name); //逛知乎
    }
    function  play()
    {
        this.phone->play(this.name);//玩农药
    }
    function  grab()
    {
        this.phone->grab(this.name);//抢红包
    }
}
const $phone = new IphoneX(); //创建一个iphoneX的实例
if($phone->isBroken()){ //如果iphone不可用，则使用旧版手机
    $phone = new Iphone6();
}
const $ming = new Ming($phone);//小明不用关心是什么手机，他只要玩就行了。
$ming->read();
$ming->play();
$ming->grab();

上面的操作用专业的词的说法：使用了依赖注入（DI)

反转的是什么：依赖对象的获取被反转了

有三种类型的依赖注入：
- 构造函数注入：依赖关系是通过 class 构造器提供的。
- setter 注入：注入程序用客户端的 setter 方法注入依赖项。
- 接口注入：依赖项提供了一个注入方法，该方法将把依赖项注入到传递给它的任何客户端中。客户端必须实现一个接口，该接口的 setter 方法接收依赖。