【TypeScript】常见的设计模式

TypeScript 设计模式之【观察者模式】 观察者模式是一种行为型设计模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。当主题对象的状态发生变化时,所有依赖于它的观察者都会得到通知并自动更新。观察者模式通过解耦主题和观察者,提高了系统的灵活性和可扩展性。合理使用观察者模式,可以让你的代码更加模块化,更易于维护和扩展。喜欢的话就❤️,关注一下吧,有问题也欢迎讨论指教。!!下期预告: TypeScript 设计模式之【状态模式】 阅读详情

设计模式就是软件开发过程中形成的套路和经验总结,熟悉设计模式能够在编程过程中更高效有自信,毕竟是前人印证过的最好的设计,同时也能够更好地掌控项目,方便预估开发时间以及对团队成员进行管理。

通常所提的前端工程化,设计模式才是前端工程化的灵魂。

一、类型分类

可以将设计模式分为三种类型,分别为创建型,结构型,和行为型。

类型说明
创建型模式主要解决对象创建什么,由谁创建,何时创建的3w问题,对类的实例化进行了抽象,分离概念和实现,使得系统更加符合单一职责原则。
结构型模式描述如何将类或者对象组合在一起,形成更大的数据结构,因此也可以分为类结构型和对象结构型。
行为型模型对不同的对象划分责任和算法的抽象,关注类和对象之间的相互作用,同样也分为类和对象。

二、创建型模式

创建型模式一共有4个,分别为工厂(工厂,工厂方法,抽象工厂合并),建造者,原型,单例。

工厂模式

简而言之,工厂模式就是要替代掉“new操作符”*

new执行步骤:

  • 在内存中创建一个新对象
  • 让构造函数的this指针指向这个空对象
  • 执行构造函数内的操作
  • 返回这个新对象

原因:因为有时候创建实例时需要大量的准备工作,而将这些准备工作 全部放在构造函数 中是非常危险的行为,有必要 将 创建实例的逻辑 和 使用实例的逻辑 分开 ,方便以后扩展。

class People {
 
  constructor(des) {
 
    // 出现异步不能使用async await
    // 函数调用时可能还未完成初始化
    get('someUrl').then(data => {
 
      this.name = data.name
      get('someUrl?name=' + this.name).then(data => {
 
        this.age = data.age
      })
    })
    // 非成员函数耦合性变大
    this.des = handleDes(des)
  }
}

使用ts+工厂模式的实现:

class People {
 
  name: string = ''
  age: number = 0
  des: string = ''
  constructor(name: string, age: number, des: string) {
 
    this.name = name
    this.age = age
    this.des = des
  }
}

async function peopleFactory(description:any){
 
  const name = await get('someUrl')
  const age = await get('someUrl?name='+name)
  const des = handle(description)
  return new People(name,age,des)
}

如此封装,可以使对象的创建和使用更清楚地分离。同时,如果之后的类的定义发生了改变,可以直接修改People,创建类的准备数据发生了改变,则修改工厂函数。

但是,选择工厂模式的原因是因为构造函数足够复杂或者对象的创建面临巨大的不确定性,只需要传入变量即可构造的情况下,用工厂函数实际上是得不偿失的。

几乎所有的设计模式都会带来代码可读性下降的风险,因此需要找到代码可读性降低和可维护性,稳定性之间的平衡。

建造者模式

用于直接构建复杂对象,将一个对象的初始化和后续步骤分开,通过将初始化和不同的后续步骤结合可以创建出不同的结果。

export class UserBuilder {
 
	private _age : number;
  private _name : string;
  private _email : string;
  constructor(name : string) {
 
  	this._name = name;
  }
  setAge(age : number): UserBuilder {
 
  	this._age = age;
    return this;
  }
  get age() {
 
  	return this._age;
  }
  setEmail(email : string): UserBuilder {
 
  	this._email = email;
    return this;
  }
  get email() {
 
  	return this._email;
  }
  build() {
 
  	return new User(this)
  }
}
export class User {
 
	private _age : number;
  private _name : string;
  private _email : string;
  constructor(builder: UserBuilder) {
 
  	this._age = builder.age;
    this._name = builder.name;
    this._email = builder.email;
  }
  get age() {
 
  	return this._age;
  }
  get name() {
 
  	return this._name;
  }
  get email() {
 
  	return this._email;
  }
}

建造者模式的使用:
const user : User = new UserBuilder("啦啦啦啦")
	.setAge(20)
  .setEmail("Scojing1031@163.com")
  .build();
console.log(user.age + user.email + user.name)

仅仅三个属性远没有达到复杂对象的程度,只有在对象十分复杂的时候才需要用到建造者模式。

原型模式

使用原型模式的话,创建新对象时就是基于一个对象的拷贝,而不是重新实例化一个类。就是指定一个实例对象做原型,然后通过复制这个对象创建一个新对象。

实现:借助 Object.create() 方法可以直接指定一个原型,并可以通过参数对原型的属性进行重写或者添加。 注意如果没对原型上的属性进行重写,当原型上的属性变化时会影响继承对象上的属性。

function peopleConfigPrototype (){
 
    return {
 
        name: '',
        age: 0,
        email: ''
    }
}
这样每次返回的都是新的对象,也可以相当于是对象的拷贝,但是如果直接拷贝对象,应该如下:
const peopleConfigPrototype = {
 
    name: '',
    age: 0,
    email: ''
}
const peopleConfig = Object.create(peopleConfigPrototype)
// 采用Object.create方法,当前对象将被复制到peopleConfig的__proto__上

单例模式

单例模式的目的是限制一个类只能被实例化一次,防止多次实例化(即确保一个class只有一个实例提供给全局访问)。

class Singleton {
 
  private static instance: Singleton;
  
  public static getInstance(): Singleton {
 
  	// 判断是否已经new过1个实例
    if (!Singleton.instance) {
 
    		// 如果这个唯一的实例不存在,那么就先创建它
      Singleton.instance = new Singleton();
    }
		// 如果这个唯一的实例已经存在,就直接返回
    return Singleton.instance;
  }
}
var s1 = Singleton.getInstance();
var s2 = Singleton.getInstance();

console.log(s1 === s2);				//true

三、结构性模式

结构性模式一共有7种:适配器、桥接、组合、装饰、外观、享元、代理

装饰模式

装饰模式是在不改变原有对象的前提下,动态地给一个对象增加一些额外的功能。

直接继承car,添加颜色,一个装饰模式如下:

class Car {
 
  name: string
  constructor(name: string) {
 
    this.name = name
  }
}

class Benz extends Car {
 
  color: string
  constructor(name: string, color: string) {
 
    super(name)
    this.color = color
  }
}

采用的继承方法是静态的,会导致在继承复用的过程中耦合,比如Car2继承Car,在创建新的子类时错把Car2作为父类,结果容易出错。
可以采用Ts的装饰器特性来解决这个问题:
function colorDecorator<T extends {
    new(...args: any[]): {
   } }>(color: string) {
 
    return function (constructor: T) {
 
        return class extends constructor {
 
            name = 'shit'
            color = color
        }
    }
}

@colorDecorator<Car>('red')
class Car {
 
    name: string
    constructor(name: string) {
 
        this.name = name
    }
}

装饰器会拦截Car的构造函数,生成一个继承自Car的新的类,这样更加灵活(但是注意这个过程只发生在构造函数阶段)。

外观模式

外观模式就是为子系统中的一系列接口提供一个统一的接口。

为轮胎、方向盘、车这些提供一个统一的接口:

class Tyre{
 
    name: string
    constructor(name: string){
 
        this.name = name
    }
}

class Steering{
 
    turnRight(){
 }
    turnLeft(){
 }
}

interface CarConfig{
 
    tyreName: string
    ifTurnRight: boolean
}

class Car{
 
    tyre:Tyre
    steering:Steering
    constructor(carConfig: CarConfig){
 
        this.tyre = new Tyre(carConfig.name)
        this.steering = new Steering()
        if(carConfig.ifTurnRight){
 
            this.steering.turnRight
        }
    }
}

代理模式

代理模式就是为某个对象提供一个代理,并由这个代理对象控制对原对象的访问。封装复杂类。

比如说car有很多属性,而我们只需要一个简单的版本:

class Car{
 
    a: number = 1
    b: number = 2
    c: number = 3
    d: number = 4
    name: string = 'name'
    test(){
 
        console.log('this is test')
    }
}

class CarProxy{
 
    private car: Car
    name: number
    constructor(){
 
        if(this.car === null){
 
            this.car = new Car
        }
        this.name = this.car.name
    }
    test(){
 
        this.car.test()
    }
}

四、行为型模式

行为型模式主要有5种:命令、中介者、观察者、状态、策略

观察者模式

观察者模式是定义对象间的一种「一对多依赖关系」,使得每当一个对象状态发生改变时,其相关依赖对象皆得到通知并被自动更新。观察者模式是一种对象行为型模式。

观察者模式的目的是为了“检测变更”,既然要检测变更,自然需要记录之前的信息。

典型应用:在 Vue 中,每个组件实例都有相应的 watcher 实例对象,它会在组件渲染的过程中把属性记录为依赖,之后当依赖项的 setter 被调用时,会通知 watcher 重新计算,从而致使它关联的组件得以更新。

class Observer{
 
    states: string[] = []
    update(state: string){
 
        this.states.push(state)
    }
}

class People{
 
    state: string = ''
    observer: Observer
    
    setState(newState: string){
 
        if(this.state !== newState){
 
            this.state = newState
            this.notify(this.state)
        }
    }
    notify(state: string){
 
        if(this.observer !== null){
 
            this.observer.update(state)
        }
    }
    setObserver(observer: Observer){
 
        this.observer = observer
    }
}

const observer = new Observer()
const people = new People().serObserver(observer)

people.setState('shit')
console.log(observer.state)

可以把观察者模式看成是“记录事件”。实际上前端很多事件处理,就是基于观察者模式的,在上例中的update中的state,就是事件名称,js的事件循环会轮流处理states的状态变化。

拓展:观察者模式与发布-订阅模式的区别是什么?

  • 发布者直接触及到订阅者的操作,叫观察者模式。

  • 发布者不直接触及到订阅者、而是由统一的第三方来完成实际的通信的操作,叫做发布-订阅模式。

状态模式

状态模式指对象的行为根据状态改变而改变。

与观察者模式相对,表示的是“记录状态”,只要状态变更,表现即不同,这是设计数据驱动的基础。

class State{
 
    tmp: string
    set store(state: string){
 
        if(this.tmp !== state){
 
            // do something
            this.tmp = state
        }
    }
    get store(): string{
 
        return this.tmp
    }
}

class People{
 
    state: State
    constructor(state: State){
 
        this.state = state
    }
}

const state = new State()
const people = new People(state)

state.store = 1
console.log(people.state.store)

当然,如果一个数据接口既能记录事件,又能记录状态,这就是传说中的响应式数据流,也就是大家平时使用的ReactiveX。

TypeScript 设计模式之【组合模式】 组合模式是一种结构型设计模式,它允许你将对象组合成树形结构来表示"部分-整体"的层次结构。这种模式让客户端能够以一致的方式处理单个对象和对象组合,大大简化了客户端代码。它具有简化客户端代码、易于扩展、提高灵活性等优点,但也可能导致设计过于一般化。在处理树形结构的问题时,组合模式是一个非常有用的工具。喜欢的话就❤️,关注一下吧,有问题也欢迎讨论指教。!!下期预告:TypeScript 设计模式之【装饰模式】 阅读详情

相关推荐

TypeScript 设计模式之【迭代器模式】

迭代器模式是一种行为型设计模式,它提供了一种方法顺序访问一个聚合对象中的各个元素,而又不暴露该对象的内部表示。迭代器模式使得我们可以轻松地遍历各种复杂的数据结构,而无需了解其内部实现细节。合理使用迭代器模式,可以让你的代码更加简洁、灵活,并且更易于维护和扩展。喜欢的话就❤️,关注一下吧,有问题也欢迎讨论指教。!!下期预告: TypeScript 设计模式之【中介者模式】

bobostudio1995的博客 1160

图解23种设计模式(TypeScript版)——前端切图崽必修内功心法

使用思维导图来阐述23种设计模式,并以TypeScript实现其代码,让我们前端切图崽写出的代码具有可扩展性、可复用性、减少代码冗余问题,提升自身内功。 一、设计原则 二、创建型模式 2.1 单例模式 // 饿汉式 class Singleton1 { // 1. 构造器私有化,外部不能new private constructor(){} // 2. 本类内部创建对象实例化 private static instance : Singleto.

m173net的博客 1509

TypeScript 进阶-第六篇:TypeScript 中的函数与类-设计模式应用

在软件开发领域,设计模式是经过验证的、用于解决常见问题的通用解决方案。TypeScript作为一种强类型的编程语言,为实现各种设计模式提供了有力支持,借助其特性,我们能够编写出更健壮、易维护且可读性高的代码。接下来,我们将深入探讨TypeScript中常见设计模式的实现以及基于其特性的优化。

无 216

TypeScript 设计模式开源项目常见问题解决方案

TypeScript 设计模式开源项目常见问题解决方案 一、项目基础介绍 本项目是Savjee Tutorials提供的TypeScript设计模式实现。该项目包含了常见的面向对象设计模式的TypeScript实现代码,适用于希望学习和应用设计模式于TypeScript开发中的开发者。项目主要使用的编程语言是TypeScript。 二、新手常见问题及解决步骤 问题一:如何开始运行和测试项目? 问题...

gitblog_00318的博客 972

QUIC 协议域名封堵:核心原理、关键技术与实现路径(C/C++代码实现)

随着 QUIC 协议在互联网领域的广泛应用,其基于 UDP 的传输特性与加密设计,打破了传统 TCP 协议下的域名封堵逻辑,给网络合规管理与安全防护带来新的技术难题。本文将脱离具体代码实现,聚焦 QUIC 协议域名封堵的核心原理、关键技术环节与实际落地路径,从协议特性本质出发,解析如何在遵循 RFC 9000、RFC 9001 等规范的前提下,实现对 QUIC 流量的精准域名封堵。

chen1415886044的博客 1469

别再只调IoU了!给YOLOv8换上NWDLoss,实测小目标检测精度提升明显

本文深入探讨了YOLOv8在小目标检测中的优化策略,重点介绍了NWDLoss(Normalized Wasserstein Distance Loss)的应用优势。通过对比实验证明,NWDLoss能有效解决传统IoU损失函数的局限性,显著提升小目标检测精度,在遥感影像和交通监控等场景中表现尤为突出。文章提供了详细的代码实现和训练技巧,帮助开发者快速集成这一先进技术。

weixin_29072299的博客 283

Cocos Creator 之 typescript几种常见的设计模式

Cocos Creator 之 typescript几种常见的设计模式

来自上海的这位朋友 3927

别再搞错了!ERA5-Land小时数据里的辐射值,原来不是你想的那个‘瞬时值’

本文深入解析ERA5-Land小时数据中辐射值的累积特性,揭示其与瞬时值的本质区别。通过详细的数据处理方法和Python代码示例,指导研究者正确转换累积辐射量为实用瞬时值,避免常见误区,提升气候模型验证的准确性。

weixin_28700411的博客 212

TypeScript 设计模式教程

TypeScript 设计模式教程 项目介绍 本项目是基于 TypeScript 实现的设计模式教程,由 Packt Publishing 出版。项目旨在通过实际代码示例,帮助开发者理解和应用常见的设计模式。设计模式是软件开发中解决常见问题的通用解决方案,能够提升代码的可维护性、可扩展性和复用性。 项目快速启动 环境准备 安装 Node.js:确保你已经安装了 Node.js(建议版本 >...

gitblog_00809的博客 523

2024年最全scrapy+scrapyd+gerapy 爬虫调度框架,字节跳动面试时间

scrapyd是一个用于部署和运行scrapy爬虫的程序,它允许你通过JSON API来部署爬虫项目和控制爬虫运行,scrapyd是一个守护进程,监听爬虫的运行和请求,然后启动进程来执行它们方便地控制爬虫运行直观地查看爬虫状态实时地查看爬取结果简单地实现项目部署统一地实现主机管理轻松地编写爬虫代码。

2401_84140653的博客 1204

GAN模型中的常见变体有哪些,如DCGAN、WGAN和CGAN等?

生成对抗网络(GAN)是一种强大的深度学习模型,它由生成器和判别器两个网络组成,通过对抗训练的方式实现生成数据的能力。随着研究的发展,出现了许多GAN的变体,每个变体都有其独特的改进和特点。

huidhsu的博客 2262

TypeScript 泛型常见问题解析:从类型参数到运行时类型检查

TypeScript 的泛型系统是类型安全的重要保障,但在实际使用中开发者经常会遇到一些困惑。本文将通过几个典型问题,深入解析 TypeScript 泛型的工作原理和使用技巧。 ## 泛型类型兼容性问题 ### 问题现象 当定义一个泛型接口时,即使类型参数不同,实例之间也可能互相赋值: ```typescript interface Something { name: strin...

gitblog_00873的博客 546

小程序 video 控制器外观调整_Kessil 360X Tuna Sun无线控制器使用分享

之前分享了Kessil 360X Tuna Sun开箱记录,时间关系,没来得及使用WiFi Dongle无线控制器。昨晚抽空实操了一下,做个操作记录,希望对大家有参考Kessil无线模块操作指南官方视频英文教程配中文字幕,非常详尽语速较快,重点位置可以暂停操作点击边框调出视频工具条1、拆包取控制器,保存二维码Kessil WiFi Dongle包装打开包装就能看到Kessil无线控制模...

weixin_39759060的博客 4734

TypeScript语言的软件工程

TypeScript是由微软开发的一种开源语言,首次发布于2012年。它在JavaScript的基础上,增加了类型系统和一些面向对象的特性。TypeScript的设计初衷是为了提升大型应用的开发效率,并在编译时检测潜在的错误。

2501_90168293的博客 630

Doris Streamloader安装教程

Doris Streamloader 是一款用于将数据导入 Doris 数据库的专用客户端工具。本文介绍其在centos7环境下的安装过程

qq_44540985的博客 1094

Open3D 曲率下采样

曲率下采样是一种基于几何特征的点云处理技术,通过计算每个点的曲率来判断其所在位置的局部表面特征,从而进行选择性保留。曲率的计算通常基于点的法向量和其邻域点的分布。

纵马踏花向自由 846

TypeScript设计模式持续集成配置:GitHub Actions自动化构建流程终极指南

在现代软件开发中,持续集成(CI)已成为保障代码质量和开发效率的关键实践。本文将为您提供一个完整指南,帮助您为TypeScript设计模式项目配置GitHub Actions自动化构建流程,实现代码提交后的自动测试、构建和质量检查,确保每一次代码变更都能保持项目的稳定性和可靠性。 ## 为什么需要持续集成配置? 持续集成通过自动化构建、测试和部署流程,帮助开发团队: - 及早发现代码错误和兼容

gitblog_00358的博客 619

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

ECS框架常见问题解决方案

ECS框架常见问题解决方案 一、项目基础介绍 ECS框架(Entity-Component-System)是一种用于游戏开发的设计模式,它可以帮助开发者更高效地构建游戏。该框架通过将实体、组件和系统分离,使得代码更加模块化,便于管理和扩展。本项目是一个开源的ECS框架,适用于使用TypeScript或JavaScript语言的引擎,如Egret、LayaBox和Cocos等。 主要编程语言:Typ...

gitblog_00543的博客 756

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

告别混乱代码!Cocos Creator TypeScript接口与类型别名最佳实践指南

你是否还在为引擎接口定义混乱而头疼?是否因类型别名使用不当导致团队协作效率低下?本文将系统梳理Cocos Creator的TypeScript接口设计规范与类型别名最佳实践,带你写出更易维护的游戏代码。读完本文你将掌握:基础类型定义规范、接口设计模式、类型别名优化技巧、常见错误案例分析。 ## 类型系统基础架构 Cocos Creator引擎的TypeScript类型系统集中定义在[@type...

gitblog_00794的博客 1203

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

23种设计模式实战解析与常见误区

设计模式是面向对象编程中解决特定问题的经典方案,其本质是可复用的设计经验。从创建型模式(如单例、工厂)到结构型模式(如适配器、代理),再到行为型模式(如观察者、策略),每种模式都针对特定场景提供了优雅的解决方案。理解设计模式能显著提升代码的可维护性和扩展性,广泛应用于框架开发、系统架构等领域。但在实践中需避免过度设计和生搬硬套,特别是在现代语言特性(如装饰器、Hooks)逐渐替代传统模式实现的今天。通过电商促销策略、订单状态管理等真实案例,可以深入掌握设计模式的核心思想与应用技巧。

weixin_30647423的博客 257

ts的接口和类的区别、js中设计模式

接口 1、一般用来定义数据结构,因为ts中的interface不同于其它强类型语言的一点是,interface中可以定义变量,这就使得interface还可以充当一些model对象的基类使用,而并非通常的用来定义一些行为。 2、接口只声明成员方法,不做实现。 类 类声明并实现方法,面向对象编程 常见的设计模式有 单例模式 工厂模式 观察者模式 发布订阅模式 策略模式 代理模式 迭代器模式 ……等等很多 这个大哥写的设计模式文章很好 ...

tjq11111的博客 738

前端常见的6个设计模式和使用场景

前端场景设计模式:工厂模式、单例模式、代理模式、观察者模式、发布订阅模式、装饰器模式

qq_40784926的博客 426

TypeScript入门第一天,所有类型+基础用法+接口使用

interface A { //定义了一个接口 AName:“小陈”,age:21,console.log("Customer 对象 ")console.log(customer.Name) //小陈。

2401_84438067的博客 304

前端常用设计模式学习笔记

设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。设计模式可以分为下面三种类型:1、创建型模式:用来描述 “如何创建对象”,它的主要特点是 “将对象的创建和使用分离”。包括单例、原型、工厂方法、抽象工厂和建造者 5 种模式。2、结构型模式:用来描述如何将类或对象按照某种布局组成更大的结构。

花姐夫JUN的博客 266

JavaScript设计模式在前端开发中的实战应用

设计模式是软件开发中解决特定问题的经典方案,在前端开发中尤为重要。JavaScript作为一门灵活的语言,其设计模式实现与传统的OOP语言有所不同。理解设计模式能帮助开发者构建更清晰的代码结构,提升团队协作效率,并优雅解决常见问题。单例模式适用于全局状态管理,工厂模式常用于组件创建,而观察者模式则广泛用于事件处理。这些模式在现代前端框架如React和Vue中都有广泛应用,例如React的高阶组件和Vue的混入机制。掌握设计模式不仅能提升代码质量,还能优化性能,避免常见陷阱。

weixin_29001683的博客 270
上一篇: 在SpringBoot下,tomcat的运行模式:BIO、NIO、APR
下一篇: 理解JS的三座大山
JavaShark
博客等级 码龄4年 184粉丝 438原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值