Should I use polymorphism in javascript?

Question

I am a programmer who has programmed in several languages, both functional and OO oriented. I programmed some Javascript too, but never used (or had to use) polymorphism in it.

Now, as kind of a hobby project, I would like to port some apps that were written in Java and C# that heavily use polymorhpism to Javascript.

But at a first glance I read lots of 'It's possible but ...'

So is there an alternative to it?

An example of what I would like to write in JS in pseudolang :

abstract class Shape{ { printSurface() } ;  }  class Rect : Shape() {  printSurface() { print (sideA*sideB}}  class Circle : Shape() {  printSurface() { print { pi*r*r }}  TheApp { myshapes.iterate(shape s) {s.printSurface() } } 

So a classic polymorphic case : iterating over baseclass.

I would like to achieve this kind of behaviour. I know it is polymorhism, but are there any other 'patterns' that I am overlooking that achieve this kind of behaviour or should I study the inheritance possibilities in Javascript?

Answer 1

As said, JavaScript is a dynamic typed language based on prototypal inheritance, so you can't really use the same approach of typed languages. A JS version of what you wrote, could be:

function Shape(){   throw new Error("Abstract class") }  Shape.prototype.printSurface = function () {   throw new Error ("Not implemented"); }  function Rect() {   // constructor; }  Rect.prototype = Object.create(Shape.prototype); Rect.prototype.printSurface = function() {   // Rect implementation }  function Circle() {   // constructor; }  Circle.prototype = Object.create(Shape.prototype); Circle.prototype.printSurface = function() {   // Circle implementation } 

Then, in your app:

var obj = new Circle();  if (obj instanceof Shape) {     // do something with a shape object } 

Or, with duck typing:

if ("printSurface" in obj)     obj.printSurface();  // or  if (obj.printSurface)     obj.printSurface();  // or a more specific check if (typeof obj.printSurface === "function")     obj.printSurface(); 

You cold also have Shape as object without any constructor, that it's more "abstract class" like:

var Shape = {     printSurface : function () {         throw new Error ("Not implemented");     } }  function Rect() {   // constructor; }  Rect.prototype = Object.create(Shape); Rect.prototype.printSurface = function() {   // Rect implementation }  function Circle() {   // constructor; }  Circle.prototype = Object.create(Shape); Circle.prototype.printSurface = function() {   // Circle implementation } 

Notice that in this case, you can't use instanceof anymore, so or you fallback to duck typing or you have to use isPrototypeOf, but is available only in recent browsers:

if (Shape.isPrototypeOf(obj)) {     // do something with obj } 

Object.create is not available in browser that doesn't implement ES5 specs, but you can easily use a polyfill (see the link).

Answer 2

The "pattern" in play here would be "interface". As long as all the objects in the myshapes collection implement the printSurface() method, you will be fine.

Since Javascript is a dynamically typed language, the objects in a collection don't need to be related at all.