Often during the course of my day I come across code which evaluates the same conditional comparisons in multiple contexts. Understandably, this is rather typical of most software systems, and while it may only introduce a negligible amount of technical dept (in the form of redundancy) for smaller systems, that dept can grow considerably in more complex, large scale applications. From a design perspective, this issue is applicable to nearly every language.<\/p>\n
For example, consider a simple Technically, there is nothing problematic with the above class signature; the defined constants certainly provide a much better design than conditional comparisons against literal strings throughout implementation code. That being said, this design does lead to redundancy as every instance of For example, to test for Likewise, simular comparisons would need to be implemented for each cardinal direction. And, while this may seem trivial for a class as simple as the With this in mind, we can simplify client code by defining each state as a specific method of Based on the above implementation of To simplify implementing conditional comparisons, I have provided a simple Compass<\/code> class which defines just one public property, “direction” and, four constants representing each cardinal direction: North, East, South and West, respectively. In JavaScript, this could be defined simply as follows:<\/p>\n\r\nvar Compass = function(direction){\r\n this.direction = direction;\r\n}\r\nCompass.NORTH = \"North\";\r\nCompass.EAST = \"East\";\r\nCompass.SOUTH = \"South\";\r\nCompass.WEST = \"West\";\r\n<\/pre>\nCompass<\/code> which needs to evaluate the state of direction<\/code> requires conditional comparisons. <\/p>\nCompass.North<\/code>, typically, client code must be implemented as follows: <\/p>\n\r\nif (compass.direction === Compass.NORTH) { \r\n \/\/...\r\n}\r\n<\/pre>\nCompass<\/code> example, it does become a maintenance issue for more complex implementations. <\/p>\nCompass<\/code>. In doing so, we afford our code the benefit of exercising (unit testing) Compass<\/code> exclusively. This alone improves maintainability while also simplifying client code which depends on Compass<\/code>. As such, Compass<\/code> could be refactored to:<\/p>\n\r\nvar Compass = function(direction){\r\n this.direction = direction;\r\n}\r\nCompass.prototype = {\r\n isNorth: function() {\r\n return this.direction === Compass.NORTH;\r\n },\r\n isWest: function() {\r\n return this.direction === Compass.WEST;\r\n },\r\n isSouth: function() {\r\n return this.direction === Compass.SOUTH;\r\n },\r\n isEast: function() {\r\n return this.direction === Compass.EAST;\r\n }\r\n}\r\n<\/pre>\nCompass<\/code>, the previous conditional comparison can be refactored as follows:<\/p>\n\r\nif (compass.isNorth()) { \r\n \/\/...\r\n}\r\n<\/pre>\nComparator API<\/h3>\n
Comparator<\/code> API that defines a single static method: Comparator.each<\/code>, which allows for augmenting existing objects with comparison methods. Comparator.each<\/code> can be invoked with three arguments as follows:<\/p>\n