常见 JavaScript 设计模式 — 原来这么简单

JS的设计模式(23种) 抽象工厂模式提供一个接口用于创建一系列相关或相互依赖的对象,而无需指定具体类。客户端使用此接口选择所需的产品族中的产品对象。 阅读详情

设计模式

设计模式总共有 23 种,但在前端领域其实没必要全部都去学习,毕竟大部分的设计模式是在 JavaScript 中占的比重并不是那么大,本文会列举出一些 JavaScript 常见的、容易被忽视的设计模式,不过还是有必要先简单了解一下设计模式相关的概念.

设计模式是什么?

先举个形象的例子,比如现在正在考试而且恰好在考数学,实际上每道数学题目都对应着一种或多种解决公式(如和三角形相关的勾股定理),而这些解决公式是经过数学家研究、推导、总结好的,我们只需要把 题目 和 已有公式 对应上就很容易解决问题,而 设计模式 也是如此,只不过是它是相对于 软件设计领域 而言的.

设计模式(Design pattern) 是一套被反复使用、经过分类、代码设计经验的总结,简单来说设计模式就是为了解决 软件设计领域 不同场景下相应问题的 解决方案.

设计原则(SOLID)

SOLID 实际上指的是五个基本原则,但在前端领域涉及到最多的是仍然是前面两条:

  • 单一功能原则(Single Responsibility Principle)
  • 开放封闭原则(Opened Closed Principle)
  • 里式替换原则(Liskov Substitution Principle)
  • 接口隔离原则(Interface Segregation Principle)
  • 依赖反转原则(Dependency Inversion Principle)

设计模式的类型

主要分为三个类型:

  • 创建型
    • 主要用于解耦 对象的实例化 过程,即用于创建对象,如对象实例化
    • 本文主要包含:简单工厂模式、抽象工厂模式、单例模式、原型模式
  • 行为型
    • 主要用于优化不同 类、对象、接口 间的结构关系,如把 类 或 对象 结合在一起形成一个更大的结构
    • 本文主要包含:装饰器模式、适配器模式、代理模式
  • 结构型
    • 主要用于定义 类 和 对象 如何交互、划分责任、设计算法
    • 本文主要包含:策略模式、状态模式、观察者模式、发布订阅模式、迭代器模式

创建型设计模式

设计模式的核心是区分逻辑中的 可变部分 和 不变部分,并使它们进行分离,从而达到使变化的部分易扩展、不变的部分稳定.

工厂模式

简单工厂模式

核心就是创建一个对象,这里的 可变部分 是 参数,不变部分 是 共有属性.

举例:通过不同职级的员工创建员工相关信息,需要包含 name、age、position、job 等信息.

实现方式一:

  • 核心就是 可变部分 默认 参数化
function Staff(name, age, position, job) {
    this.name = name;
    this.age = age;
    this.position = position;
    this.job = job;
}

const developer = new Staff('zs', 18, 'develoment', ['写 bug', '改 bug', '摸鱼']);
const productManager = new Staff('ls', 30, 'manager', ['提需求', '改需求', '面向 PPT 开发']);

实现方式二:

  • 实际上在实现方式一中的 job 部分是和 position 是相互关联的,可以认为 job 部分是 不变的,因此可以根据 position 内容的内容来自动匹配 job
function Staff(name, age, position, job) {
    this.name = name;
    this.age = age;
    this.position = position;
    this.job = job;
}

function StaffFactory(name, age, position){
    let job = []
    switch (position) {
        case 'develoment':
            job = ['写 bug', '改 bug', '摸鱼'];
            break;
        case 'manager':
            job = ['提需求', '改需求', '面向 PPT 开发'];
            break;
        ...
    }

    return new Staff(name, age, position, job);
}

const developer = StaffFactory('zs', 18, 'developer');
const productManager = StaffFactory('ls', 30, 'manager');

抽象工厂模式

这个模式最显眼的就是 抽象 两个字了,在如 Java 语言当中存在所谓的 抽象类,这个抽象类里面的所有属性和方法都没有具体实现,只有单纯的定义,而继承这个抽象类的子类必须要实现其对应的抽象属性和抽象方法.

在 JavaScript 中没有这样的直接定义,不过根据上面的描述其实我们可以把它映射到 typescript 中的 interface 接口,理解到这其实让我联想到了 vue.js 中的 自定义渲染器,预留的自定义渲染器的各个方法目的就是实现跨平台的渲染方式

// 文件位置:packages\runtime-core\src\renderer.ts
export function createRenderer<
  HostNode = RendererNode,
  HostElement = RendererElement
>(options: RendererOptions<HostNode, HostElement>) {
  return baseCreateRenderer<HostNode, HostElement>(options)
}

// 文件位置:packages\runtime-core\src\renderer.ts
// RendererOptions 就是一个 Interface 接口
export interface RendererOptions<
  HostNode = RendererNode,
  HostElement = RendererElement
> {
  patchProp(
    el: HostElement,
    key: string,
    prevValue: any,
    nextValue: any,
    isSVG?: boolean,
    prevChildren?: VNode<HostNode, HostElement>[],
    parentComponent?: ComponentInternalInstance | null,
    parentSuspense?: SuspenseBoundary | null,
    unmountChildren?: UnmountChildrenFn
  ): void
  insert(el: HostNode, parent: HostElement, anchor?: HostNode | null): void
  remove(el: HostNode): void
  createElement(
    type: string,
    isSVG?: boolean,
    isCustomizedBuiltIn?: string,
    vnodeProps?: (VNodeProps & { [key: string]: any }) | null
  ): HostElement
  createText(text: string): HostNode
  createComment(text: string): HostNode
  setText(node: HostNode, text: string): void
  setElementText(node: HostElement, text: string): void
  parentNode(node: HostNode): HostElement | null
  nextSibling(node: HostNode): HostNode | null
  querySelector?(selector: string): HostElement | null
  setScopeId?(el: HostElement, id: string): void
  cloneNode?(node: HostNode): HostNode
  insertStaticContent?(
    content: string,
    parent: HostElement,
    anchor: HostNode | null,
    isSVG: boolean,
    start?: HostNode | null,
    end?: HostNode | null
  ): [HostNode, HostNode]
}

接下来我们将以上的 typescript 的形式转变成 JavaScript 形式的抽象模式:

// 抽象 Render 类
class Renderer {
  patchProp(
    el,
    key,
    prevValue,
    nextValue,
    isSVG,
    prevChildren,
    parentComponent,
    parentSuspense,
    unmountChildren
  ) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  insert(el, parent, anchor) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  remove(el) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  createElement(type, isSVG, isCustomizedBuiltIn, vnodeProps) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  createText(text) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  createComment(text) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  setText(node, text) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  setElementText(node, text) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  parentNode(node) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  nextSibling(node) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  querySelector(selector) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  setScopeId(el, id) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  cloneNode(node) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
  insertStaticContent(content, parent, anchor, isSVG, start, end) {
    throw Error('抽象工厂方法不能直接使用,你需要将我重写!!!');
  }
}

// 具体渲染函数的实现
class createRenderer extends Renderer{
    // 待实现的渲染器方法
    ...
}

单例模式

核心就是通过多次 new 操作进行实例化时,能够保证创建 实例对象 的 唯一性.

vuex 中的单例模式

其实,vuex 中就使用到了 单例模式,代码本身比较简单,当 install 方法被多次调用时,就会得到一个错误信息,并不会多次向 Vue 中混入 vuex 中自定义的内容:

image.png

实现一个单例模式

这里举个封装 localStorage 方法的例子,并提供给外部对应的创建方法,如下:

let storageInstance = null;

class Storage {
    getItem(key) {
        let value = localStorage.getItem(key);
        try {
            return JSON.parse(value);
        } catch (error) {
            return value;
        }
    }

    setItem(key, value) {
        try {
            localStorage.setItem(JSON.stringify(value));
        } catch (error) {
            // do something
            console.error(error);
        }
    }
}

// 单例模式
export default function createStorage(){
    if(!storageInstance){
        storageInstance = new Storage();
    }
    return storageInstance;
}

原型模式

在 JavaScript 中原型模式是很常见的,JavaScript 中实现的 继承 或者叫 委托 也许更合适,因为它不等同于如 Java 等语言中的继承,毕竟 JavaScript 的 继承 是基于原型(prototype)来实现.

class Person {
    say() {
        console.log(`hello, my name is ${this.name}!`);
    }

    eat(foodName) {
        console.log(`eating ${foodName}`);
    }
}

class Student extends Person {
    constructor(name) {
        super();
        this.name = name;
    }
}

const zs = new Student('zs');
const ls = new Student('ls');

console.log(zs.say === ls.say);// Java 中是不相等的, JavaScript 中是相等的
console.log(zs.eat === ls.eat);// Java 中是不相等的, JavaScript 中是相等的

vue2 中的原型模式

文件位置:\src\core\instance\lifecycle.js

image.png

结构型设计模式

装饰器模式

核心是在不改变原 对象/方法 的基础上,通过对其进行包装拓展,使原有 对象/方法 可以满足更复杂的需求.

装饰器本质

装饰器模式本质上就是 函数的传参和调用,通过函数为已有 对象/方法 进行扩展,而不用修改原对象/方法,满足 开放封闭原则.

通过配置 babel 通过将 test.js 转为为 bable_test.js 用来查看装饰器的本质:

babel.config.json

{
  "presets": [
    [
      "@babel/preset-env",
      {
        "targets": {
          "node": "current"
        }
      }
    ]
  ],
  "plugins": [
    ["@babel/plugin-proposal-decorators", { "legacy": true }],
    ["@babel/plugin-proposal-class-properties", { "loose": true }]
  ]
}

test.js

// 定义装饰器
function decoratorTest(target) {
  console.log(target);
}

// 使用装饰器,装饰 Person 类
@decoratorTest
class Person {
  say() {}
  eat() {}
}

执行 babel test.js --out-file babel_test.js 命令是生成 babel_test.js

"use strict";

var _class;

function decoratorTest(target) {
  console.log(target);
}

let Person = decoratorTest(_class = class Person {
  say() {}

  eat() {}

}) || _class;

React 中的装饰器模式 —— HOC 高阶组件

高阶组件 是参数为 组件,返回值为新组件的 函数,在 React 中 HOC 通常用于复用组件公共逻辑.

// TodoList 组件
class TodoList extends React.Component {}

// HOC 函数
function WrapContainer(Comp) {
  return (
    <div style={{ border: "1px solid red", padding: 10 }}>
      <Comp title="todo" />
    </div>
  );
}

// HOC 装饰 TodoList 组件,为 TodoList 组件包裹红色边框
const newTodoList = WrapContainer(TodoList);

适配器模式

适配器模式本质就是 让原本不兼容的功能能够生效,避免大规模修改代码,对外提供统一使用.

Axios 中的适配器

通过观察 Axios 的目录结构,很容就发现其使用了适配器模式:

image.png

其实 Axios 中的 adapters 主要目的是根据当前运行时环境,向外返回对应的适配器 adapter,而这个适配器要做的其实就是兼容 web 浏览器环境和 node 环境的 http 请求,保证对外暴露的仍然是统一的 API 接口

代理模式

代理模式顾名思义就是 不能直接访问目标对象,需要通过代理器来实现访问,通常是为了提升性能、保证安全等.

事件代理

事件代理是很常见的性能优化手段之一,react 的事件机制也采用了事件代理的方式(篇幅有限可自行了解),这里演示简单的 JavaScript 事件代理:

<div id="container">
  <p>this number is 1</p>
  <p>this number is 2</p>
  <p>this number is 3</p>
  <p>this number is 4</p>
  <p>this number is 5</p>
</div>

<script>
  const container = document.querySelector("#container");
  container.addEventListener("click", function (e) {
    alert(e.target.textContent);
  });
</script>

Vue 中的代理 Proxy

Vue.js 3 中通过 Proxy 实现了对数据的代理,任何读取、设置的操作都会被 代理对象 的 handlers 拦截到,从而实现 Vue 中的 track 和 trigger

行为型设计模式

策略模式

策略模式实际上就是定义一系列的算法,将单个功能封装起来,并且对扩展开放.

举个例子

假如我们需要为某个游乐场的门票价格做差异化询价,主要人员类型分为 儿童、成年人、老年人 三种,其对应的门票折扣为 8折、9折、8.5折

if-else 代码一把梭

缺点:无论哪种人员类型的折扣变动,都需要修改 finalPrice 函数,不符合对 对修改封闭

function finalPrice(type, price) {
  if (type === "child") {
    // do other thing
    return price * 0.8;
  }

  if (type === "adult") {
    // do other thing
    return price * 0.9;
  }

  if (type === "aged") {
    // do other thing
    return price * 0.85;
  }
}

单一功能封装

缺点:若人员类型增加妇女类型,仍然需要修改 finalPrice 函数,且不符合 对扩展开放

function childPrice(price) {
  // do other thing
  return price * 0.8;
}

function adultPrice(price) {
  // do other thing
  return price * 0.9;
}

function agedPrice(price) {
  // do other thing
  return price * 0.85;
}

function finalPrice(type, price) {
  if (type === "child") {
    return childPrice(price);
  }

  if (type === "adult") {
    return adultPrice(price);
  }

  if (type === "aged") {
    return agedPrice(price);
  }
}

创建映射关系

通过映射关系,很好的将 finalPrice 和 具体的计算逻辑进行分离,在需要扩展类型时,只需要修改 priceTypeMap 对象而不用修改对外暴露的 finalPrice 函数.

const priceTypeMap = {
  child: function (price) {
    // do other thing
    return price * 0.8;
  },
  adult: function (price) {
    // do other thing
    return price * 0.9;
  },
  aged: function (price) {
    // do other thing
    return price * 0.85;
  },
};

function finalPrice(type, price) {
    return priceTypeMap[type](price);
}

状态模式

状态模式允许一个对象在其内部状态发生改变时,能够改变原本的行为.

举例子

假如现在我们需要设计一个售票机器,主要出售 巴士、火车、飞机票等,价格分别为 50、150、1000,并且能够根据剩余票数决定是否能够继续购买.

通过策略模式实现核心代码逻辑

有了上面的 策略模式 的思想,立马就可以设计出如下的代码:

缺点:没有根据剩余票数决定是否可以继续售卖,主要原因就在于抽离的 ticketTypeMap 和 TicketMachine 之间的状态没有关联

const ticketTypeMap = {
  bus() {
    // do other thing
    return 50;
  },
  train() {
    // do other thing
    return 150;
  },
  plane() {
    // do other thing
    return 1000;
  },
};

class TicketMachine {
  constructor() {
    // 剩余票数
    this.remain = {
      bus: 100,
      train: 150,
      plane: 200,
    };
  }

  selling(type) {
    return ticketTypeMap[type]();
  }
}

关联对象状态 — 函数传参

通过函数传参的方式将对象传递给目标函数,让目标函数通过该对象访问和修改对象内部的状态.

const ticketTypeMap = {
  bus(remain) {
    if (remain.bus <= 0) return Error("抱歉,巴士票已售完");
    remain.bus--;
    return 50;
  },
  train(remain) {
    if (remain.train <= 0) return Error("抱歉,火车票已售完");
    remain.train--;
    return 150;
  },
  plane(remain) {
    if (remain.plane <= 0) return Error("抱歉,飞机票已售完");
    remain.plane--;
    return 1000;
  },
};

class TicketMachine {
  constructor() {
    // 剩余票数
    this.remain = {
      bus: 100,
      train: 150,
      plane: 200,
    };
  }

  selling(type) {
    return ticketTypeMap[type](this.remain);
  }
}

关联对象状态 — 整合方法

实际上 ticketTypeMap 映射的方法和 TicketMachine 有较强的关联性,不应该单独存在,因此,可以将这个映射对象整合进 TicketMachine 当中

class TicketMachine {
  constructor() {
    // 剩余票数
    this.remain = {
      bus: 100,
      train: 150,
      plane: 200,
    };
  }

  ticketTypeMap = {
    that: this,
    bus() {
      const { remain } = this.that;
      if (remain.bus <= 0) return Error("抱歉,巴士票已售完");
      remain.bus--;
      return 50;
    },
    train() {
      const { remain } = this.that;
      if (remain.train <= 0) return Error("抱歉,火车票已售完");
      remain.train--;
      return 150;
    },
    plane() {
      const { remain } = this.that;
      if (remain.plane <= 0) return Error("抱歉,飞机票已售完");
      remain.plane--;
      return 1000;
    },
  };

  selling(type) {
    return this.ticketTypeMap[type]();
  }
}

观察者模式

观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个目标对象,当这个目标对象的状态发生变化时,会通知所有观察者对象,使它们能够自动更新.

vue 中的观察者模式

vue 中的响应式原理就使用了 观察者模式,我们简单回顾一下其工作流程:

  • compile:将模板内容编译得到对应的 render 渲染函数
  • render:渲染函数执行生成 VNode,通过 patch 函数初始化视图 view
    • Observe:负责将 data 中返回的对象进行数据劫持(getter/setter),且其中会使用 Dep 来实现 watcher 的存储,相当于 被观察者
    • Dep:在触发 getter 时执行 dep.depend() 实际上执行的是 watcher.addDep(),该方法会将当前的 dep 对象保存到 Watcher,同时将当前的 watcher 通过 dep.addSub() 添加到 Dep 中
    • Watcher:相当于 观察者,提供统一的 update() 方法供 Dep 调用
  • data changed:响应式数据发生变更,触发数据劫持操作 setter
    • 进而执行 dep.notify() 方法,通过循环去执行 watcher.update() 方法,即执行 queueWatcher() 将 watcher 添加到 queue 队列中
    • 最后由 scheduler 调度器 中执行 nextTick(flushSchedulerQueue) 进行异步队列刷新操作

以上过程中,显然 Observe 和 Watcher 就是 被观察者 和 观察者 ,因为 Observe 中实现了对 Watcher 的收集和监听到数据状态发生变化时通知 Watcher 更新的处理,可以认为 Dep 只是 Observe 中使用到的一个存储和派发 Watcher 的工具.

发布订阅模式

发布订阅模式有三个核心:发布者、事件中心、订阅者,且发布订阅模式中的 发布者 和 订阅者 不能直接进行通信,必须要经过 事件中心 来统一调度.

与观察者模式的区别

实际上,发布订阅模式和观察者模式在概念上非常相似,做的事情也都一致,主要区别在于:

  • 发布订阅模式依赖于 事件中心 统一调度 发布者 和 订阅者,发布者 和 订阅者 不直接进行通信
  • 观察者模式中的 被观察者 和 观察者 是直接建立连接的,被观察者 需要保存 观察者 的信息,观察者 需要提供统一的 方法 供观察者进行使用

实现发布订阅模式

vue 中的 全局事件总线(Event Bus)和 node 中的 Event Emitter,甚至是浏览器中的事件注册(addEventListener)和执行,它们都属于发布订阅模式.

下面实现一个简单的发布订阅模式:

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

  on(name, handle) {
    if (!this.handlers[name]) {
      this.handlers[name] = [];
    }

    this.handlers[name].push(handle);
  }

  emit(name, ...args) {
    if (this.handlers[name]) {
      this.handlers[name].forEach((handle) => {
        handle(...args);
      });
    }
  }

  off(name, handle) {
    if (this.handlers[name]) {
      this.handlers[name] = this.handlers[name].filter((h) => {
        if (handle) return h !== handle;
        return false;
      });
    }
  }

  once(name, handle) {
    const onceHandle = (...args) => {
      handle(...args);
      this.off(name, onceHandle);
    };

    this.on(name, onceHandle);
  }
}

迭代器模式

迭代器模式是指提供一种方法顺序访问一个聚合对象中的各个元素,而又不需要暴露该对象的内部表示,核心目的就是 遍历.

JavaScript 中的遍历方式

  • Array :for…of、for…in、forEach、map、filter
  • Object :for…in
  • Map :for…of、forEach
  • Set :for…of、forEach

看起来很难有一种方法能够兼容以上几种数据结构的遍历方式,即不需要考虑数据结构本身就能实现遍历的目的,但我们可以基于 ES6 的 Symbol.iterator 实现自定义迭代器.

Symbol.iterator 实现通用迭代

Symbol.iterator 为每一个对象定义了默认的迭代器,拥有该迭代器后就可以被 for...of 循环使用.

function $each(data, handle) {
  if (typeof data !== "object") throw TypeError("data should be object!");

  if (!data[Symbol.iterator]) {
    Object.prototype[Symbol.iterator] = function () {
      let i = 0;
      let keys = Reflect.ownKeys(this);
      return {
        next() {
          const done = i >= keys.length;
          return {
            value: done ? undefined : keys[i++],
            done,
          };
        },
      };
    };
  }

  for (const item of data) {
    handle(item);
  }
}

最后

大前端的各种新技术层出不穷,很容易忽视如数据结构、设计模式等基础内容,笔者最近也正在学习设计模式相关的内容,其实看很多设计模式相关的内容,很少有讲得简单易懂的,这里还是向那些需要学习设计模式相关内容的同学推荐修言大佬的 JavaScript 设计模式核⼼原理与应⽤实践 .

javascript 常见设计模式 JavaScript 中常见的设计模式帮助开发者解决代码组织、复用和扩展的问题。:确保一个类仅有一个实例,并提供一个全局访问点。在JavaScript中,这通常通过创建一个对象并在需要时返回这个对象的引用来实现。:定义一个创建对象的接口,但让子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类中进行。在JavaScript中,这通常通过函数实现,该函数根据传入的参数返回不同类型的对象。:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 阅读详情

相关推荐

基于FPGA的示波器设计

ADC 、DAC、FPGA、LCD液晶、示波器

FDL_AQ的博客 1万+

UI设计工具JS design 即时设计

3.Figma (推荐)与即时设计相似的工具。

狗剩的专栏 819

【Azure 架构师学习笔记】- Azure Databricks (1) - 环境搭建

Databricks 已经成为了数据科学的必备工具,今时今日你已经很难抛开它来谈大数据,它常用于做复杂的ETL中的T, 数据分析,数据挖掘等,特别适用于做数据建模,机器学习等。那么顺应时代,现在也来看看这个工具的内容。首先要有一个环境,基于Azure 的Databricks简称ADB。托管在Azure 上的Databricks已经被Azure进行了很大的优化, 在搭建时只需要简单的几步即可拥有一个环境,不过要提醒一句ADB的集群并不便宜,用完马上删掉或停止, 否则一晚过百美金就会烧掉。

MVP黄钊吉(發糞塗牆) 2304

盘点JavaScript设计模式(常用十五大设计模式)

javaScript设计模式前言一、设计原则单一职责原则(SRP)最少知识原则(LKP)开放-封闭原则(OCP)里氏替换原则 The Liskov Substitution Principle (LSP)接口分离原则 The Interface Segregation Principle (ISP)依赖倒置原则 The Dependency-Inversion Principle (DIP)二、JavaScript设计模式1、单例模式2、策略模式3、代理模式4、迭代器模式5、发布-订阅模式6、命令模式7、组

qq_41311259的博客 3653

manimgl安装

安装manimgl

happytree001的博客 712

神经网络:初学者指南(专业版)

神经网络是一种受生物大脑启发的计算模型,由多层互连的人工神经元组成。本文从生物神经元结构出发,介绍了感知器模型、激活函数、网络架构(输入/隐藏/输出层)等基础概念,并详细阐述了前向传播、反向传播、损失函数和优化器等核心训练机制。同时涵盖了CNN、RNN等常见架构,以及过拟合、梯度消失等关键挑战,最后概述了神经网络在计算机视觉、NLP等领域的广泛应用。全文系统性地梳理了神经网络的基础理论和实践要点,为初学者提供了清晰的学习路径。

weixin_42107409的博客 1793

八大最常用的JavaScript设计模式

设计模式(Design pattern) 是解决软件开发某些特定问题而提出的一些解决方案也可以理解成解决问题的一些思路。通过设计模式可以帮助我们增强代码的可重用性、可扩充性、 可维护性、灵活性好。我们使用设计模式最终的目的是实现代码的 高内聚 和 低耦合。通俗一点讲的话 打比方面试官经常会问你如何让代码有健壮性。其实把代码中的变与不变分离,确保变化的部分灵活、不变的部分稳定,这样的封装变化就是代码健壮性的关键。而设计模式的出现,就是帮我们写出这样的代码。设计模式就是解决编程里某类问题的通用模板,总结出来的.

sdasadasds的博客 1567

别再手动算考勤了!教你用Python+企业微信API自动生成月度报表

本文介绍如何利用Python和企业微信API构建自动化考勤分析系统,实现从数据获取到可视化报表生成的全流程自动化。通过企业微信打卡接口获取数据,使用Pandas进行高效清洗和分析,并生成Excel和HTML格式的报表,大幅提升考勤统计效率。系统支持智能判定考勤状态,如迟到、早退等,并可通过定时任务实现月度自动化运行。

weixin_27875131的博客 294

JsDesignMode第一篇

1.灵活的语言JS 1.1验证表单 function checkName(){ //验证姓名 } //创建了全局变量 1.2函数的另一种形式 var checkName = function(){ //验证姓名 } //别人定义相同的方法会覆盖掉原有的方法...

qq_45517916的博客 575

Mplus—随机截距交叉滞后模型(RI-CLPM)语法

随机截距交叉滞后模型RI-CLPM的Mplus语法。

m0_54401011的博客 2542

Cesium 场景特效之【全球海洋】GL2兼容版

Cesium 场景特效之【全球海洋】GL2兼容版

喜欢钻研前端和分享技术 1280

简单介绍几种常见的JavaScript设计模式

JavaScript是一种弱类型、动态的、基于原型的语言,由于语言的特殊性使得我们在书写JavaScript代码时候感觉到非常容易,甚至我们用很简单的方式都能实现一些设计模式,接下来我来简单的介绍几种常见的设计模式并利用JavaScript代码来实现它们 一、单体模式 单体模式:一个特定类的多个实例对象都指向同一个实例对象。 在JavaScript中没有类只有对象,当你创建一个对象时候并不会有其他对象与其类似,所以当我们用字面量创建一个对象时,其实就是一个JavaScript的单体例子。由于JavaScri

qq_16483541的博客 576

YOLO26涨点改进 |独家创新,小目标涨点改进篇 | Arxiv 2025 | MHAF‑YOLO,引入RepHMS高效特征提取模块,适合轻量级目标检测、小目标检测、图像分类、旋转目标检测、实例分割

本文提出了一种改进的YOLO26目标检测模型,通过引入RepHMS模块和多分支辅助特征金字塔结构(MAFPN),显著提升了模型性能。RepHMS模块采用多分支异构卷积和重参数化策略,在不增加推理开销的情况下增强多尺度特征提取能力,尤其提升了小目标检测效果。实验表明,改进后的MHAF-YOLO模型在COCO数据集上仅用7.1M参数就达到48.9% AP,相比YOLO11-s参数量减少24.4%而性能提升1.9%。文章详细介绍了RepHMS模块的原理、实现代码及在YOLO26中的集成方法,并提供了两种改进配置。

Ai缝合怪、助力小伙伴高效发论文 203

高级前端工程师必备的 JS 设计模式入门教程,常用设计模式案例分享

        什么是设计模式?为什么要有设计模式?单例模式、工厂模式、建造者模式、适配器模式、代理模式、装饰器模式、观察者模式、策略模式、状态模式分别是什么?他们解决了什么样的问题?本文将给您答案。

RenGJ010617的博客 6975

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

JavaScript设计模式 -- 工厂模式

工厂模式属于创建型设计模式,其核心思想是将对象的创建过程封装起来,让调用者只需关注产品接口,而无需了解具体实现。这样可以降低系统各模块之间的耦合度,使得扩展和维护更加方便。简单工厂模式:由一个工厂类根据参数创建不同的产品实例;工厂方法模式:通过定义抽象工厂接口,让子类决定实例化哪一个具体产品;抽象工厂模式:用于创建一系列相关或相互依赖的产品。接下来,我们分别介绍这些模式在 JavaScript 中的实现,并结合多种场景给出示例。工厂模式通过封装对象创建逻辑,使得代码具有更好的解耦性和扩展性。

u014676858的博客 1467

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

JavaScript设计模式

Javascript 设计模式 第一章 灵活的javascript 用函数收编对象 var checkobject={ checkname:function(){}, checkemail:function(){}, checkpassword:function(){} } 真假对象 Var checkobject=function(){ R...

weixin_30659829的博客 73

OpenClaw voice-call 语音通话插件演进全解:从首发功能矩阵到 TTS 核心迁移

本文以 OpenClaw 官方语音通话插件 `@openclaw/voice-call` 的 [CHANGELOG](https://link.gitcode.com/i/e05ee99edeaa32e9da3397e18e401e3a) 为骨架,系统梳理该插件自 `0.1.0` 首发以来的能力矩阵与关键破坏性变更。你将了解:插件支持哪些电信提供商(Twilio / Telnyx / Plivo

gitblog_00434的博客 727

JS设计模式之创建型设计模式总结

JS设计模式: 创建型设计模式, 简单工厂模式, 工厂方法模式, 抽象工厂模式 原型模式, 单例模式

Hei, Welcome To vickie's Blog,Good Good Study, Day Day Up ~ 1256

在不同开发语言与场景下设计模式的使用

《设计模式在不同技术栈中的实践与权衡》 本文探讨了设计模式在不同编程语言中的实际应用与差异。设计模式作为对抗代码熵增的有效工具,在不同技术栈中展现出独特形态:Java强调严谨解耦,Vue/TS注重模块化组合,Python追求动态灵活。文章对比了工厂方法、构建器、单例等常见模式在三种语言中的实现差异,并强调务实应用的重要性,提出"可读性优于炫技"和"简单性原则"两大过滤器,建议避免过度设计,根据实际需求选择最简洁的解决方案。

Zero小葵司的博客 1174

前端常用几种设计模式

本篇将介绍以下几个比较常见的设计模式: 工厂模式 单例模式 代理模式 观察者模式 策略模式 模块模式 构造函数模式 混合模式 一、工厂模式 工厂模式是用来创建对象的一种最常用的设计模式,不暴露创建对象的具体逻辑,而是将逻辑封装在一个函数中,那么这个函数就可以被视为一个工厂,工厂模式根据抽象程度的不同可以分为:简单工厂,工厂方法和抽象工厂,接下来,将对简单工厂和工厂方法在JavaScript中的运用举个简单的例子: 1. 简单

qq_45845127的博客 3746

javascript设计模式_前端5大常见设计模式、代码一看你就懂!

前言今天主要介绍一下我们平常会经常用到的设计模式,设计模式总的来说有23种,而设计模式在前端中又该怎么运用呢,接下来主要对比较前端中常见的设计模式做一个介绍。设计模式的定义设计模式是在面向对象软件设计过程中针对特定问题的简洁而优雅的解决方案。在不同的编程语言中,对设计模式的实现其实是可能会有区别的。比如java和javascript,在Java这种静态编译型语言中,无法动态地给已存在的对象添加职责...

weixin_39938855的博客 155

5 修改request对象变量_【总结】前端5大常见设计模式,代码一看你就懂!

前言今天主要介绍一下我们平常会经常用到的设计模式,设计模式总的来说有23种,而设计模式在前端中又该怎么运用呢,接下来主要对比较前端中常见的设计模式做一个介绍。设计模式的定义设计模式是在面向对象软件设计过程中针对特定问题的简洁而优雅的解决方案。在不同的编程语言中,对设计模式的实现其实是可能会有区别的。比如java和javascript,在Java这种静态编译型语言中,无法动态地给已存在的对...

weixin_28996657的博客 142

headfirst设计模式_[译] 现代 JavaScript 开发中的设计模式

原文地址:Design patterns in modern JavaScript development原文作者:Kristian Poslek译文出自:掘金翻译计划本文永久链接:github.com/xitu/gold-m…译者:Hyde Song校对者:xujiujiu, ezioyuan关于软件项目设计中有效沟通的思考模式?设计?我们是在讨论软件开发么?当然是啦。就像面向对象编程一样,我们...

weixin_39611506的博客 179

Javascript常见设计模式

Javascript常见设计模式:单例模式、工厂模式、发布订阅者与观察者模式、代理模式、策略模式

警警的博客 2274

JS的几种设计模式

JS的几种简单设计模式

k464746的博客 1万+

JavaScript中常见的设计模式

js常见的设计模式与开发实践。单例模式、策略模式、代理模式、迭代器模式、发布-订阅模式(观察者模式)、命令模式、组合模式、模板方法模式、享元模式、职责链模式、中介者模式、装饰者模式、状态模式、适配器模式

逆水寒 1737
上一篇: 重新认识 JavaScript 中的 this
下一篇: 前端 “一键换肤“ 的几种方案
熊的猫
博客等级 码龄8年 1066粉丝 79原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址