Comment puis-je créer une classe de base abstraite en JavaScript?

Un moyen simple de créer une classe abstraite est ceci:

/**
 @constructor
 @abstract
 */
var Animal = function() {
    if (this.constructor === Animal) {
      throw new Error("Can't instantiate abstract class!");
    }
    //Animal initialization...
};

/**
 @abstract
 */
Animal.prototype.say = function() {
    throw new Error("Abstract method!");
}

La Animal "classe" et le say méthode abstraite.

La création d'une instance renvoie une erreur:

new Animal(); //throws

C'est la façon dont vous "hériter" de celle-ci:

var Cat = function() {
    Animal.apply(this, arguments);
    //Cat initialization...
};
Cat.prototype = Object.create(Animal.prototype);
Cat.prototype.constructor = Cat;

Cat.prototype.say = function() {
    console.log('meow');
}

Dog semble juste comme ça.

Et c'est de cette façon que votre scénario se joue:

var cat = new Cat();
var dog = new Dog();

cat.say();
dog.say();

Violon ici (regardez la sortie de la console).

JavaScript Classes et Héritage (ES6)

Selon ES6, vous pouvez utiliser JavaScript classes et l'héritage d'accomplir ce que vous avez besoin.

Classes JavaScript, introduit dans ECMAScript 2015, sont essentiellement syntaxique de sucre sur du JavaScript prototype existant à base d'héritage.

Référence: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes

Tout d'abord, nous définissons notre classe abstraite. Cette classe ne peut pas être instanciée, mais il peut être prolongé.
Nous pouvons également définir des fonctions qui doivent être mis en œuvre dans toutes les classes, qui s'étend de celui-ci.

/**
* Abstract Class Animal.
*
* @class Animal
*/
class Animal {
constructor() {
if (this.constructor == Animal) {
throw new Error("Abstract classes can't be instantiated.");
}
}
say() {
throw new Error("Method 'say()' must be implemented.");
}
eat() {
console.log("eating");
}
}

Après cela, nous pouvons créer nos Classes concrètes. Ces classes héritent de toutes les fonctions et du comportement de la classe abstraite.

/**
* Dog.
*
* @class Dog
* @extends {Animal}
*/
class Dog extends Animal {
say() {
console.log("bark");
}
}
/**
* Cat.
*
* @class Cat
* @extends {Animal}
*/
class Cat extends Animal {
say() {
console.log("meow");
}
}
/**
* Horse.
*
* @class Horse
* @extends {Animal}
*/
class Horse extends Animal {}

Et les résultats...

//RESULTS
new Dog().eat(); //eating
new Cat().eat(); //eating
new Horse().eat(); //eating
new Dog().say(); //bark
new Cat().say(); //meow
new Horse().say(); //Error: Method say() must be implemented.
new Animal(); //Error: Abstract classes can't be instantiated.

Est-il possible de simuler la classe de base abstraite en JavaScript?

Certainement. Il y a environ mille et une façons de mettre en œuvre la classe/instance systèmes en JavaScript. En voici une:

//Classes magic. Define a new class with var C= Object.subclass(isabstract),
//add class members to C.prototype,
//provide optional C.prototype._init() method to initialise from constructor args,
//call base class methods using Base.prototype.call(this, ...).
//
Function.prototype.subclass= function(isabstract) {
if (isabstract) {
var c= new Function(
'if (arguments[0]!==Function.prototype.subclass.FLAG) throw(\'Abstract class may not be constructed\'); '
);
} else {
var c= new Function(
'if (!(this instanceof arguments.callee)) throw(\'Constructor called without "new"\'); '+
'if (arguments[0]!==Function.prototype.subclass.FLAG && this._init) this._init.apply(this, arguments); '
);
}
if (this!==Object)
c.prototype= new this(Function.prototype.subclass.FLAG);
return c;
}
Function.prototype.subclass.FLAG= new Object();

var chat = new Animal('chat');

Ce n'est pas vraiment une classe de base abstraite de cours. Voulez-vous dire quelque chose comme:

var Animal= Object.subclass(true); //is abstract
Animal.prototype.say= function() {
window.alert(this._noise);
};
//concrete classes
var Cat= Animal.subclass();
Cat.prototype._noise= 'meow';
var Dog= Animal.subclass();
Dog.prototype._noise= 'bark';
//usage
var mycat= new Cat();
mycat.say(); //meow!
var mygiraffe= new Animal(); //error!

function Animal(type) {
if (type == "cat") {
this.__proto__ = Cat.prototype;
} else if (type == "dog") {
this.__proto__ = Dog.prototype;
} else if (type == "fish") {
this.__proto__ = Fish.prototype;
}
}
Animal.prototype.say = function() {
alert("This animal can't speak!");
}
function Cat() {
//init cat
}
Cat.prototype = new Animal();
Cat.prototype.say = function() {
alert("Meow!");
}
function Dog() {
//init dog
}
Dog.prototype = new Animal();
Dog.prototype.say = function() {
alert("Bark!");
}
function Fish() {
//init fish
}
Fish.prototype = new Animal();
var newAnimal = new Animal("dog");
newAnimal.say();

Ce n'est pas garanti de fonctionner comme __proto__ n'est pas une variable standard, mais il fonctionne au moins dans Firefox et Safari.

Si vous ne comprenez pas comment il fonctionne, lire sur la chaîne de prototype.

Question est assez vieux, mais j'ai créé une certaine solution possible comment créer résumé de "classe" et de bloquer la création d'un objet de ce type.

JS:

//our Abstract class
var Animal=function(){
this.name="Animal";
this.fullname=this.name;
//check if we have abstract paramater in prototype
if (Object.getPrototypeOf(this).hasOwnProperty("abstract")){
throw new Error("Can't instantiate abstract class!");
}
};
//very important - Animal prototype has property abstract
Animal.prototype.abstract=true;
Animal.prototype.hello=function(){
console.log("Hello from "+this.name);
};
Animal.prototype.fullHello=function(){
console.log("Hello from "+this.fullname);
};
//first inheritans
var Cat=function(){
Animal.call(this);//run constructor of animal
this.name="Cat";
this.fullname=this.fullname+" - "+this.name;
};
Cat.prototype=Object.create(Animal.prototype);
//second inheritans
var Tiger=function(){
Cat.call(this);//run constructor of animal
this.name="Tiger";
this.fullname=this.fullname+" - "+this.name;
};
Tiger.prototype=Object.create(Cat.prototype);
//cat can be used
console.log("WE CREATE CAT:");
var cat=new Cat();
cat.hello();
cat.fullHello();
//tiger can be used
console.log("WE CREATE TIGER:");
var tiger=new Tiger();
tiger.hello();
tiger.fullHello();
console.log("WE CREATE ANIMAL ( IT IS ABSTRACT ):");
//animal is abstract, cannot be used - see error in console
var animal=new Animal();
animal=animal.fullHello();

Comme Vous pouvez le voir le dernier objet de nous donner l'erreur, c'est parce que les Animaux à l'état de prototype a bien abstract. Pour être sûr qu'il est Animal n'est pas quelque chose qui a Animal.prototype dans la chaîne de prototype, je n':

Object.getPrototypeOf(this).hasOwnProperty("abstract")

Donc je vérifier que mon plus proche du prototype de l'objet a abstract de propriété, seul objet créé directement à partir de Animal prototype aura cette condition sur la valeur true. Fonction hasOwnProperty vérifie uniquement les propriétés de l'objet courant pas de ses prototypes, donc cela nous donne à 100% sûr que la propriété est déclarée ici, pas dans la chaîne de prototype.

Chaque objet est descendu de l'Objet hérite de la hasOwnProperty méthode. Cette méthode peut être utilisée pour déterminer si un objet a la propriété spécifiée comme une propriété de l'objet; à la différence de l'opérateur, cette méthode ne permet pas de vérifier en bas de l'objet prototype de la chaîne. Plus à ce sujet:

Dans ma proposition de nous de ne pas avoir à changer constructor à chaque fois après Object.create comme c'est actuellement la meilleure réponse par @Jordão.

Solution permet aussi de créer plusieurs classes abstraites dans la hiérarchie, nous avons seulement besoin de créer abstract de la propriété à l'état de prototype.

Javascript peut avoir de l'héritage, consultez l'URL ci-dessous:

http://www.webreference.com/js/column79/

Andrew

//Your Abstract class Animal
function Animal(type) {
this.say = type.say;
}
function catClass() {
this.say = function () {
console.log("I am a cat!")
}
}
function dogClass() {
this.say = function () {
console.log("I am a dog!")
}
}
var cat = new Animal(new catClass());
var dog = new Animal(new dogClass());
cat.say(); //I am a cat!
dog.say(); //I am a dog!

/****************************************/
/* version 1                            */
/****************************************/
var Animal = function(params) {
this.say = function()
{
console.log(params);
}
};
var Cat = function() {
Animal.call(this, "moes");
};
var Dog = function() {
Animal.call(this, "vewa");
};
var cat = new Cat();
var dog = new Dog();
cat.say();
dog.say();
/****************************************/
/* version 2                            */
/****************************************/
var Cat = function(params) {
this.say = function()
{
console.log(params);
}
};
var Dog = function(params) {
this.say = function()
{
console.log(params);
}
};
var Animal = function(type) {
var obj;
var factory = function()
{
switch(type)
{
case "cat":
obj = new Cat("bark");
break;
case "dog":
obj = new Dog("meow");
break;
}
}
var init = function()
{
factory();
return obj;
}
return init();
};
var cat = new Animal('cat');
var dog = new Animal('dog');
cat.say();
dog.say();