【02问:前端常见的设计模式】

一、策略模式

简单来说就是一个问题匹配多个解决方案,不一定使用哪个,而且后续可能会继续增加或减少方案。主要

目录

一、策略模式

二、单例模式

方法一:使用对象字面量

方法二:使用闭包

三、观察者模式

[方法一:使用 ES6 类](#方法一:使用 ES6 类)

方法二:使用函数和闭包

方法三:使用事件机制

四、工厂模式


解决在多种相似算法存在时,使用条件语句(如if...else)导致的复杂性和难以维护的问题。

例如,购物车满减:

  • 满100减10
  • 满200减20
  • 8折
  • ......

使用策略模式实现:

<script>
        // 以闭包的形式把折扣方案保存
        const calcPrice = (function () {
            const sale = {
                '100_10': function (price) { return price -= 10 },
                '200_20': function (price) { return price -= 20 },
                '80%': function (price) { return price *= 0.8 },
            }

            // 计算折扣
            function calcPrice(price, type) {
                if(!sale[type]) return '没有这个折扣'
                return sale[type](price)
            }

            // 添加折扣
            calcPrice.add = function (type, fn) {
                if (sale[type]) return '折扣已经存在';
                sale[type] = fn
            }
            return calcPrice
        })()

        const res = calcPrice(200, '80%');
        console.log(res)
    </script>

二、单例模式

使用闭包是实现单例模式的一种常见方法。通过将类的实例保存在闭包中,并提供一个公共方法来获取该实例,可以确保只有一个实例被创建和访问。

方法一:使用对象字面量

这种方法简单直接,通过对象字面量创建一个单例对象。

const singleton = {
    property: 'value',
    method: function() {
        console.log('method called');
    }
};

// 使用
singleton.method(); // 输出: method called

方法二:使用闭包

闭包是一种强大的工具,可以用来创建私有变量和方法。

const Singleton = (function() {
    let instance;

    function createInstance() {
        const object = new Object('I am the instance');
        return object;
    }

    return {
        getInstance: function() {
            if (!instance) {
                instance = createInstance();
            }
            return instance;
        }
    };
})();

// 使用
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();

console.log(instance1 === instance2); // 输出: true

三、观察者模式

观察者模式(Observer Pattern)是一种行为设计模式,它定义了一种一对多的关系,让多个观察者对象同时监听某一个主题对象。当主题对象发生变化时,它会通知所有观察者对象,使它们能够自动更新自己。

在前端开发中,观察者模式非常适用于事件处理、数据绑定等场景。以下是实现观察者模式的几种常见方法:

方法一:使用 ES6 类

使用 ES6 的类语法,可以优雅地实现观察者模式。

class Subject {
    constructor() {
        this.observers = [];
    }

    addObserver(observer) {
        this.observers.push(observer);
    }

    removeObserver(observer) {
        this.observers = this.observers.filter(obs => obs !== observer);
    }

    notifyObservers(data) {
        this.observers.forEach(observer => observer.update(data));
    }
}

class Observer {
    update(data) {
        console.log('Observer received data:', data);
    }
}

// 使用
const subject = new Subject();
const observer1 = new Observer();
const observer2 = new Observer();

subject.addObserver(observer1);
subject.addObserver(observer2);

subject.notifyObservers('some data'); // 所有观察者都会收到更新

方法二:使用函数和闭包

如果不使用类,也可以通过函数和闭包来实现观察者模式。

function createSubject() {
    let observers = [];

    function addObserver(observer) {
        observers.push(observer);
    }

    function removeObserver(observer) {
        observers = observers.filter(obs => obs !== observer);
    }

    function notifyObservers(data) {
        observers.forEach(observer => observer.update(data));
    }

    return {
        addObserver,
        removeObserver,
        notifyObservers
    };
}

function createObserver() {
    return {
        update(data) {
            console.log('Observer received data:', data);
        }
    };
}

// 使用
const subject = createSubject();
const observer1 = createObserver();
const observer2 = createObserver();

subject.addObserver(observer1);
subject.addObserver(observer2);

subject.notifyObservers('some data'); // 所有观察者都会收到更新

方法三:使用事件机制

前端的事件机制本身就很适合实现观察者模式,例如可以使用自定义事件。

class EventEmitter {
    constructor() {
        this.events = {};
    }

    on(event, listener) {
        if (!this.events[event]) {
            this.events[event] = [];
        }
        this.events[event].push(listener);
    }

    off(event, listener) {
        if (!this.events[event]) return;
        this.events[event] = this.events[event].filter(l => l !== listener);
    }

    emit(event, data) {
        if (!this.events[event]) return;
        this.events[event].forEach(listener => listener(data));
    }
}

// 使用
const emitter = new EventEmitter();

function listener1(data) {
    console.log('Listener 1 received:', data);
}

function listener2(data) {
    console.log('Listener 2 received:', data);
}

emitter.on('event', listener1);
emitter.on('event', listener2);

emitter.emit('event', 'some data'); // 所有监听器都会收到更新

emitter.off('event', listener1);
emitter.emit('event', 'some other data'); // 只有Listener 2 会收到更新

四、工厂模式

工厂模式(Factory Pattern)提供了一种创建对象的方式,使得创建对象的过程与使用对象的过程分离,而无需指定要创建的具体类。

通过使用工厂模式,可以将对象的创建逻辑封装在一个工厂类中,而不是在客户端代码中直接实例化对象,这样可以提高代码的可维护性和可扩展性。

class VehicleFactory {
    static createVehicle(type, model) {
        switch(type) {
            case 'car':
                return new Car(model);
            case 'truck':
                return new Truck(model);
            default:
                throw new Error('Unknown vehicle type');
        }
    }
}

class Car {
    constructor(model) {
        this.model = model;
    }

    drive() {
        console.log(`${this.model} car is driving`);
    }
}

class Truck {
    constructor(model) {
        this.model = model;
    }

    drive() {
        console.log(`${this.model} truck is driving`);
    }
}

// 使用
const myCar = VehicleFactory.createVehicle('car', 'Toyota');
const myTruck = VehicleFactory.createVehicle('truck', 'Ford');

myCar.drive(); // 输出: Toyota car is driving
myTruck.drive(); // 输出: Ford truck is driving
相关推荐
小阮的学习笔记2 分钟前
Vue3中使用LogicFlow实现简单流程图
javascript·vue.js·流程图
YBN娜2 分钟前
Vue实现登录功能
前端·javascript·vue.js
阳光开朗大男孩 = ̄ω ̄=2 分钟前
CSS——选择器、PxCook软件、盒子模型
前端·javascript·css
杨荧5 分钟前
【JAVA毕业设计】基于Vue和SpringBoot的服装商城系统学科竞赛管理系统
java·开发语言·vue.js·spring boot·spring cloud·java-ee·kafka
minDuck7 分钟前
ruoyi-vue集成tianai-captcha验证码
java·前端·vue.js
小政爱学习!28 分钟前
封装axios、环境变量、api解耦、解决跨域、全局组件注入
开发语言·前端·javascript
魏大帅。33 分钟前
Axios 的 responseType 属性详解及 Blob 与 ArrayBuffer 解析
前端·javascript·ajax
花花鱼39 分钟前
vue3 基于element-plus进行的一个可拖动改变导航与内容区域大小的简单方法
前端·javascript·elementui
k093343 分钟前
sourceTree回滚版本到某次提交
开发语言·前端·javascript
EricWang13581 小时前
[OS] 项目三-2-proc.c: exit(int status)
服务器·c语言·前端