Annie  Emard

Annie Emard

1651193280

DesignPatternDetector: Detection Of Design Patterns in PHP Code

Pattern Detector for PHP

Detects design pattern in your code

Installation

git clone https://github.com/Halleck45/DesignPatternDetector.git
cd DesignPatternDetector
composer install

Usage

./bin/design-pattern <source-directory>

You'll get something like:

screenshot

Why ?

Just for fun. This tool is only a proof of concept. But contributions are welcome :)

Detected patterns

Today this tool is able to detect following patterns :

  • Micro
    • Structure
  • Structural
    • Bridge
    • Decorator
    • Proxy
  • Creational
    • Singleton
    • Abstract Factory
  • Behavior
  • Anti-patterns
    • GodObject / Blob

Author: Halleck45
Source Code: https://github.com/Halleck45/DesignPatternDetector
License: MIT License

#php 

What is GEEK

Buddha Community

DesignPatternDetector: Detection Of Design Patterns in PHP Code
Samanta  Moore

Samanta Moore

1623835440

Builder Design Pattern

What is Builder Design Pattern ? Why we should care about it ?

Starting from **Creational Design Pattern, **so wikipedia says “creational design pattern are design pattern that deals with object creation mechanism, trying to create objects in manner that is suitable to the situation”.

The basic form of object creations could result in design problems and result in complex design problems, so to overcome this problem Creational Design Pattern somehow allows you to create the object.

Builder is one of the** Creational Design Pattern**.

When to consider the Builder Design Pattern ?

Builder is useful when you need to do lot of things to build an Object. Let’s imagine DOM (Document Object Model), so if we need to create the DOM, We could have to do lot of things, appending plenty of nodes and attaching attributes to them. We could also imagine about the huge XML Object creation where we will have to do lot of work to create the Object. A Factory is used basically when we could create the entire object in one shot.

As **Joshua Bloch (**He led the Design of the many library Java Collections Framework and many more) – “Builder Pattern is good choice when designing the class whose constructor or static factories would have more than handful of parameters

#java #builder #builder pattern #creational design pattern #design pattern #factory pattern #java design pattern

Joseph  Murray

Joseph Murray

1624442940

Prototype Design Pattern - Java

Prototype design pattern tutorial

Definition of Prototype pattern

The prototype pattern is a creational design pattern in software development. It is used when the type of objects to create is determined by a prototypical instance, which is cloned to produce new objects.

Where to use the Prototype pattern

If the cost for creating a new object is expensive and costs resources.

#java #design-patterns #code #tutorial #prototype-design-pattern #design pattern

Joseph  Murray

Joseph Murray

1624442280

Factory design pattern — Java

Definition of the Factory pattern

In class-based programming, the factory method pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created. This is done by creating objects by calling a _factory method _— either specified in an interface and implemented by child classes, or implemented in a base class and optionally overridden by derived classes — rather than by calling a constructor.

Where to use the Factory pattern

  • When a class doesn’t know what sub-classes will be required to create
  • When a class wants that its sub-classes specify the objects to be created.
  • When the parent classes choose the creation of objects to its sub-classes.

#factory-design-pattern #code #tutorial #design-patterns #java #factory design pattern — java

Composite design pattern — Java

Composite Pattern tutorial

Definition of Composite pattern

In software engineering, the composite pattern is a partitioning design pattern. The composite pattern describes a group of objects that are treated the same way as a single instance of the same type of object. The intent of a composite is to “compose” objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly.

Where to use the Composite pattern?

UML example

Implementation of the Composite pattern

#design-patterns #java #code #composite-design-pattern #tutorial #composite design pattern — java

Joseph  Murray

Joseph Murray

1624443360

Builder design pattern — java

Definition of Builder Pattern

The builder pattern is a design pattern that allows for the step-by-step creation of complex objects using the correct sequence of actions. The construction is controlled by a director object that only needs to know the type of object it is to create.

Where to use the builder pattern?

When you have a simple object, this pattern is not very useful, but when you begin to have a more complex object and want to have a clear code you can use it without hesitation

#tutorial #design-patterns #coding #java #builder-pattern #builder design pattern — java