Please enable JavaScript.

Coggle requires JavaScript to display documents.

JavaScript Design Patterns (Important Questions (What are the pros and…

- - - - const newObj = {};
      - const newObj = Object.create( Object.prototype );
      - const newObj = new Object();
    - - Dot Syntax
        
        newObj.somekey = 'Hello world'
      - Bracket Syntax
        
        newObj['somekey'] = 'Hello world'
      - Define Propertie(s)
    - - function Man ( name, age) { }
      - Cons
        
        Inheritance becomes difficult
        
        Locally defined functions (Man.toString()) are redefined for each new object.
        
        Local functions should be shared between all instances.
    - - Use Object.prototype.somefunction to define a shared function for a specific object
  - - - A simple object definition works as a simple version of a module
      - Can assist in encapsulating and organizing code
        
        Using Objects to Organize Code
    - - Used in conventional software engineering to provide both public and private encapsulation for classes
      - Encapsulates privacy, state, and organization using closures
        
        Utilizes IIFEs
      - Extra Reading
    - - Create API like functionality by providing a return function within the module
        
        Can shield variables within the modules closure
        
        Namespace the public methods under the module
      - Typical Module Template
        
        Namespacing
        
        var myNamespace = (function () { })();
        
        Public Vars
        
        return { myPublicVar: 'foo', ... }
        
        Private Vars
        
        var myPrivateVar, myPrivateMethod;
    - - Freedom to have private functions and members which can only be consumed by the module itself
      - Easier to show call stacks given that functions are declared normally and locally
      - Enables us to return different functions depending on the environment
    - - Import Mixins
        
        Demonstrates how Globals (jQuery, swal) can be passed in as arguments to our module's anonymous function
        
        Effectively allows us to import globals and locally alias them
      - Exports
        
        Declare globals without consuming them and support global imports as seen in Import Mixins
    - - Cleaner for OO programmers
      - Supports encapsulated data
    - - In order to change visibility, changes have to be made to each place the member is used
      - Can't access private members in methods that are added to an object at a later point
      - Cannot create automated tests for private members or easily extend them.
    - - Used to reveal public pointers to private functions and properties
      - Usage
        
        All members of the module are declared in the private scope
        
        Members are revealed with an anonymous object
      - Advantages
        
        Allows syntax to be more consistent
        
        Clearer definition of what the module is revealing as a publicly accessed member
      - Disadvantages
        
        If a private function refers to a public function, that public function can't be overridden if a patch is neccessary
        
        Public members that refer to private variables are subject to this no-patch rule as well
        
        This means the Revealing Module can be more fragile than the original Module pattern
  - - - There must be exactly one instance of a class, and it must be accessible to clients from a well-known access point.
      - When the sole instance should be extensible by subclassing, and clients should be able to use an extended instance without modifying their code.
    - - Give a class a static instance of itself.
      - If the class doesn't exist, create one.
      - If the class already exists, return a reference to the existing object.
    - - The only important difference between these two classes is that the Singleton class can be instantiated lazily
    - - Generally a sign of bad overall design.
      - Indication that modules in a system are either tightly coupled or that logic is overly spread across multiple parts of a codebase.
      - Hard to Test
        
        Hidden dependencies
        
        Difficulty creating multiple instances
        
        Difficulty stubbing dependencies
      - Use Singletons Wisely
      - Dependency Injection Myth: Reference Passing
- - - - Patterns have proven solutions
      - Patterns are easily reusable
      - Patterns can be expresive
        
        Provides a structure and vocabulary to help elegantly express large solutions
    - - Creational Design Patterns
        
        Focus on handling object creation mechanisms where objects are created in a manner suitable for the situation
      - Structural Design Patterns
        
        Focus on object composition and typically identify simple ways to realize relationships between different objects
      - Behavioral Design Patterns
        
        Focus on improving and streamlining the communication between disparate objects in a system
  - - - Anti-patterns can ruin maintainability, scalability, relationships, lives, etc.
    - - Polluting the global namespace by defining a large number of variables in the global context
      - Passing strings rather than functions to either setTimeout() or setInterval() as this triggers the use of eval() internally
      - Modifying the Object class prototype
        (this is a particularly bad anti-pattern)
      - Using JavaScript in an inline form as this is inflexible
      - The use of document.write where native DOM alternatives such as document.createElement are more appropriate
- - - - first-class functions
      - higher order functions
      - functions as arguments/values