torokmark / design_patterns_in_typescript

:triangular_ruler: Design pattern implementations in TypeScript

Design Patterns in TypeScript

Here are the implementations of the following design patterns in TypeScript:

Creational

• Singleton
• Abstract Factory
• Factory Method
• Builder
• Prototype

Structural Patterns

• Adapter
• Bridge
• Composite
• Decorator
• Facade
• Flyweight
• Proxy

Behavioral Patterns

• Chain of Responsibility
• Command
• Interpreter
• Iterator
• Mediator
• Memento
• Observer
• State
• Strategy
• Template Method
• Visitor

Compile the project

$ git clone https://github.com/torokmark/design_patterns_in_typescript.git
$ cd design_patterns_in_typescript
$ tsc

There is a tsconfig.json file in the root directory which is responsible for the compiler options.

As it is set the default target is Ecmascript5 now.

Any additional options come here.

By default the output is a patterns.js file.

To compile only one pattern, use the following command.

$ cd design_patterns_in_typescript/visitor
$ tsc --target ES5 --module system --outFile visitor.js visitor.ts

Execute the project

After the compilation of the project, a patterns.js is generated by default. Executing the file is:

node patterns.js

design_patterns_in_typescript's Issues

Hello! Prototype Pattern is right?

I think prototype pattern is reduce resource consumption.
UseObject.create(Prototype.prototype) wouldn't it be better?

Builder pattern needed?

Hi,

Since node/javascript does not have the problem that a builder pattern fixes, since you can just pass along an object literal, why would you want to apply all this overhead?

If we take a look at the example: https://github.com/torokmark/design_patterns_in_typescript/blob/master/builder/builder.ts

We could just use an object literal instead:

// user.js
const create = args => {
  const options = Object.assign({}, defaultOptions, args); // Normalize the options
  return {
    name: options.name,
    age: options.age,
    phone: options.phone, 
    address: options.address
  }
}

module.exports.create = create;

// test.js
const user = require('user.js');

const myUser = user.create({
  name: 'a name',
  age: 30
});

This achieves the same thing as the builder pattern. The main difference here is that user.js is a lot smaller than the builder.ts example. (10 lines vs 60+)
Passing along an object literal, which is very common in node, is just as readable as with a builder, but with a lot less overhead or boilerplate.

So my question is: why would you do this?

How to test the patterns?

Hi!
I wonder to know how to run this project to test and learn how the patterns work.
Thanks!

Real examples

Aim is to implement examples using the design patterns.

Project Structure

Hi Torok,

I suggest you structure the 23 design patterns into 3 categories :

• Creational Patterns
• Structural Patterns
• Behavioral Patterns

Thanks

How to debug step by step each pattern?

Hi Torok,
It is a question and not an issue. I wonder if you could describe how to debug step by step
each design pattern. Maybe generating map files would be usefull?

Thanks.