Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Delineatio exemplaria generalia sunt solutiones problematum communium in consilio programmatum. Exemplaria quaedam designata sunt communia, in tria genera maiora divisa: exemplaria creationis, exemplaria structuralia et rationes morum.

Creational Patterns

Haec exemplaria machinationes pro obiecto creationis praebent, flexibilitatem augentes et reusability codicem existendi.

1. Singleton exemplar：

   • Fac ut una tantum instantia in genere sit et punctum accessum globalem praebeat.

2. Modus Factory Modus：

   • Definire interface ad res creandas et subclasses utra classis instantiate faciant.

3. Abstract Factory Pattern (Abstract Factory)：

   • Familias rerum actis vel dependens crea sine classibus definitis expressis specificans.

4. Conditor exemplaris (builder)：

   • Constructum complexum et gradatim constructionem patitur.

5. Prototypum：

   • Novam instantiam scribendo exsistentiam crea potius quam novam creando.

Patterns structuralis

Haec exemplaria agunt de coniunctionibus obiectorum, seu inter res et illas relationes.

1. nibh modus：

   • Permittit incompatibilitates inter obiecta per "adaptorem" resolvenda.

2. EXORNATOR exemplaris (decorator)：

   • Dynamically additis muneribus obiecto.

3. Proxy modus (proxy)：

   • Praebet stanti-in vel placeholder ad aliud objectum ut accessum ad illud regat.

4. Facade：

   • Unum summus graduum interfacies praebet ut coetus interfaces in subsystem accessu.

5. Modus pontis (pons)：

   • Abstractam partem ab exsecutione separare ut independenter variari possint.

6. Compositus modus：

   • Coetus obiecti in structuram arboris totam hierarchiam repraesentare.

7. Flyweight modus：

   • Efficaciter sustinent multi lepidi res per participationem.

Morum Patterns

Haec exemplaria communicationem inter res intendunt, hoc est, quomodo res se occurrunt et officia distribuunt.

1. Strategy：

   • Series algorithmatum definias, eas singillatim encapsulare, easque converti posse.

2. Formula Modus Modus (Template Methodi)：

   • Definire compagem algorithm in methodo et exsecutionem subclassibus differre.

3. Animadverte exemplar.：

   • Una ad multa dependentia relationis inter obiecta. Cum obiectum mutatur status, omnia obiecta ab eo pendent notificabuntur et automatice renovabuntur.

4. Exemplar Iterator (Iterator)：

   • Accedunt singula elementa in objecto aggregato continue sine exponendo repraesentationem internam suam.

5. Catena responsabilitatis exemplar：

   • Da multiplicibus obiectis occasionem petendi tractandi, evitando coniunctionem inter mittente et receptorem petitionis.

6. Imperii modus (mandatum)：

   • Petitionem ut obiectum encapsulat, sino utentem clientem varias petitiones parameterizes.

7. Memento modus：

   • Cape statum internum rei et salvam hunc statum extra obiectum sine fractione encapsulationis.

8. Modus rei publicae：

   • Permittit rem mutare mores suos cum status internus mutatur.

9. Visitator modus：

   • Novas facultates rei structurae (ut structurae compositae).

10. Mediator exemplaris：

    • Definire obiectum medium simpliciorem esse commercium objectorum originalium.

11. Modus interpres (interprete)：

    • Definire repraesentationem grammaticalem linguae et sententias in lingua illa definitas interpretari.

Inter ultimum colloquium, quaesitum est de codice utendo ad exemplar scribentis editoris efficiendum. Tempus erat ut exemplaria haec consiliorum cum codice js simularet.

Exempli gratia

class PubSub {
  constructor() {
    this.events = {}; // 存储事件名称和对应的订阅者回调函数数组
  }

  // 订阅事件
  subscribe(event, callback) {
    if (!this.events[event]) {
      this.events[event] = []; // 如果事件不存在，初始化一个空数组
    }
    this.events[event].push(callback); // 将回调函数添加到订阅者的数组
  }

  // 取消订阅事件
  unsubscribe(event, callback) {
    if (!this.events[event]) {
      return;
    }
    this.events[event] = this.events[event].filter(cb => cb !== callback); // 移除指定的回调函数
  }

  // 取消特定事件的所有订阅
  unsubscribeAll(event) {
    if (this.events[event]) {
      delete this.events[event]; // 删除所有订阅者
    }
  }

  // 触发事件，使用 emit 作为方法名
  emit(event, data) {
    if (this.events[event]) {
      // 执行所有订阅者的回调函数
      this.events[event].forEach(callback => callback(data));
    }
  }

  // 检查是否有订阅者
  hasSubscribers(event) {
    return this.events[event] && this.events[event].length > 0;
  }
}

// 使用示例
const eventCenter = new PubSub();

// 订阅 'message' 事件
eventCenter.subscribe('message', (data) => {
  console.log(`Message received: ${data}`);
});

// 订阅 'greet' 事件
eventCenter.subscribe('greet', (name) => {
  console.log(`Hello, ${name}!`);
});

// 触发 'message' 事件
eventCenter.emit('message', 'Hello, Pub/Sub!');

// 触发 'greet' 事件
eventCenter.emit('greet', 'World');

// 取消对 'message' 事件的订阅
const myCallback = (data) => {
  console.log(`My callback received: ${data}`);
};
eventCenter.subscribe('message', myCallback);
eventCenter.unsubscribe('message', myCallback);

// 再次触发 'message' 事件，myCallback 不会被调用
eventCenter.emit('message', 'This message will not be received by myCallback');
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

In hoc exemplo;PubSub Classis praebet functionality sequenti:

• subscribe Modus signatores concedit ut munus callbackes subcriptio ad certum eventum.
• unsubscribe Modus signatores concedit ut callbackum functiones ab certis eventibus rescindant.
• unsubscribeAll Methodus omnes subscriptiones tollet ad certum eventum.
• emit Modus eventum triggers et functiones omnium signatorum callback exsequitur.
• hasSubscribers Methodus inhibet num signatores sint pro certo eventu.