Composite Pattern

Used to treat single objects or collections of objects in the same way

Compositions are used to create nested structures of nodes

  • a node may be a single node (leaf) or a container of nodes
  • the ability to iterate through the composite beginning from any node and moving up the tree

What we will be doing:
  • children with no children are leafs
  • children with kids are containers
  • Step 1 – Page: node.js

    
    // JavaScript Document
    define(function () {
    		'use strict';
    		
    		var Person = function (name) { //set up Person object constructor
    			this.name = name; //add name to a property of the object
    			this.children = []; //add children as property and set to empty aray
    			this.parent = null;	//add parent as property as set to null
    		};
    		
    		Person.prototype.addChild = function (child) { //set up method to add children to Person object
    			this.children.push(child);	//push the child arguement into the children array for the object
    			child.parent = this; //create a reciprocal link by setting current person as parent of child passed to the method.  We need this reciprocal link so we can traverse up and down the tree
    		};
    		
    		Person.prototype.traverseUp = function () { //set up method to traverse up
    			if (this.parent) { //check whether current object has parent
    				console.log(this.name + ' is the child of ' + this.parent.name); //if it does, log out a message
    				this.parent.traverseUp(); //then invoke traverseUp method of parent
    			} else { // if there are no parents
    				console.log(this.name + ' is the root node'); //we then know this is a root node
    			}
    		};
    		
    		Person.prototype.traverseDown = function () { //set up traverseDown
    			if (this.children.length) { //check for children
    				this.children.forEach(function (child) { //if so, iterate through children collection
    							console.log(this.name + ' is the parent of ' + child.name); //send out log statement
    							child.traverseDown(); //then invoke traverseDown on child
    				}, this);//set the context for the forEach method, so inside the handler, this still refers to current person objects
    			} else { //if no children
    				console.log(this.name + ' is a leaf node');	//then object is a leaf node
    			}
    		};
    		return Person; //return the person constructor
    });
    

    Step 2 – Page: init.js

    
    define(function(require) {
    	'use strict';
    
    	return {
    		init: function() {
    			
    			var Node = require('composite/node'), //require in node.js
    				root = new Node('Fred'), //set up nodes, al nodes are created in same way
    				child1 = new Node('John'),
    				child2 = new Node('Jane'),
    				child3 = new Node('Jack'),
    				child4 = new Node('Jill'),
    				child5 = new Node('James'),
    				child6 = new Node('Jess')
    				
    				root.addChild(child1); //add two children to root node, then leave child1 as leaf
    				root.addChild(child2);
    				
    				child2.addChild(child3); //add child nodes to child2, making it a container
    				child2.addChild(child4);
    				
    				child4.addChild(child5); //leave child3 as leaf, and make child4 a container with one child
    				
    				child5.addChild(child6); //child5 is container, and child6 is lowest leaf on the tree
    				
    				root.traverseDown(); //displays entire tree
    				root.traverseUp(); //root is the top level, so returns that root is a root node
    				
    				child6.traverseUp(); //displays entire tree
    				child6.traverseDown(); //bottom level, so returns that Jess is a leaf node with no children
    		}
    	};
    });
    

    Step 3 – Page: main.js

    
    // JavaScript Document
    require (
    	['composite/init'],
    	function (composite) {
    			'use strict';
    	
    			var examples = {
    					
    					composite: composite
    					
    				};
    			
    			window.runExample = function (example) {
    				examples[example].init();
    			};
    	}
    );
    
    

    Conclusion

    Main purpose of composite pattern is to allow single objects or collections of objects to be used in the same way

    • we don’t need to know if object is container or leaf, we can process it the same way.