【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
相关推荐
new出一个对象1 小时前
uniapp接入BMapGL百度地图
javascript·百度·uni-app
你挚爱的强哥2 小时前
✅✅✅【Vue.js】sd.js基于jQuery Ajax最新原生完整版for凯哥API版本
javascript·vue.js·jquery
y先森3 小时前
CSS3中的伸缩盒模型(弹性盒子、弹性布局)之伸缩容器、伸缩项目、主轴方向、主轴换行方式、复合属性flex-flow
前端·css·css3
前端Hardy3 小时前
纯HTML&CSS实现3D旋转地球
前端·javascript·css·3d·html
susu10830189113 小时前
vue3中父div设置display flex,2个子div重叠
前端·javascript·vue.js
IT女孩儿4 小时前
CSS查缺补漏(补充上一条)
前端·css
吃杠碰小鸡5 小时前
commitlint校验git提交信息
前端
天天进步20155 小时前
Vue+Springboot用Websocket实现协同编辑
vue.js·spring boot·websocket
虾球xz5 小时前
游戏引擎学习第20天
前端·学习·游戏引擎
我爱李星璇6 小时前
HTML常用表格与标签
前端·html