Dois-je utiliser le polymorphisme en javascript?

Comme l'a dit, le JavaScript est une dynamique tapé langage basé sur les prototypes de l'héritage, de sorte que vous ne pouvez pas vraiment utiliser la même approche des langages à typage. Un JS version de ce que vous avez écrit, pourrait être:

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
}

Ensuite, dans votre application:

var obj = new Circle();

if (obj instanceof Shape) {
    //do something with a shape object
}

Ou, avec le 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();

Le froid ont également Shape comme objet sans constructeur, que c'est plus "classe abstraite" comme:

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
}

Avis que, dans ce cas, vous ne pouvez pas utiliser instanceof plus, ou vous secours à duck-typing ou vous devez utiliser isPrototypeOf, mais il est disponible uniquement dans les navigateurs récents:

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

Objet.créer n'est pas disponible dans le navigateur qui n'est pas de mettre en œuvre ES5 specs, mais vous pouvez facilement utiliser un polyfill (voir le lien).

je sais que cela peut être fait avec prototypes mais je ne suis pas un maître de l'utiliser. je préfère l'objet littéral approche (plus facile à visualiser, et a un "privé" portée)

//shape class
var shape = function() {
    //return an object which "shape" represents
    return {
        printSurface: function() {
            alert('blank');
        },
        toInherit: function() {
            alert('inherited from shape');
        }
    }
};

//rect class
var rect = function() {
    //inherit shape
    var rectObj = shape();

    //private variable
    var imPrivate = 'Arrr, i have been found by getter!';

    //override shape's function
    rectObj.printSurface = function(msg) {
        alert('surface of rect is ' + msg);
    }

    //you can add functions too
    rectObj.newfunction = function() {
        alert('i was added in rect');
    }

    //getters and setters for private stuff work too
    rectObj.newGetter = function(){
        return imPrivate;
    }

    //return the object which represents your rectangle
    return rectObj;
}



//new rectangle
var myrect = rect();

//this is the overridden function
myrect.printSurface('foo');

//the appended function
myrect.newfunction();

//inherited function
myrect.toInherit();

//testing the getter
alert(myrect.newGetter());

Sur une autre note. Si vous souhaitez programmer le code Javascript dans un OO style à l'aide de classes, on peut le voir dans les nombreuses "classe-systèmes" pour le Javascript. Un exemple est Joose (http://joose.it).

De nombreux clients côté des cadres de mettre en place leur propre système de classe. Un exemple de ceci est ExtJS.