জাভাস্ক্রিপ্টে অ্যাবস্ট্রাক্ট বেস ক্লাস অনুকরণ করা সম্ভব? এটি করার জন্য সবচেয়ে মার্জিত উপায় কী?
বলুন, আমি এমন কিছু করতে চাই: -
var cat = new Animal('cat');
var dog = new Animal('dog');
cat.say();
dog.say();এটি আউটপুট করা উচিত: 'বার্ক', 'মায়ো'
উত্তর:
বিমূর্ত শ্রেণি তৈরির একটি সহজ উপায় হ'ল:
/**
@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!");
}Animal"শ্রেণী" এবং sayপদ্ধতি বিমূর্ত হয়।
একটি উদাহরণ তৈরি করা একটি ত্রুটি নিক্ষেপ করবে:
new Animal(); // throwsএভাবেই আপনি এটি থেকে "উত্তরাধিকারী" হন:
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 দেখতে ঠিক তেমন লাগে।
এবং এইভাবেই আপনার পরিস্থিতি ফুটে উঠেছে:
var cat = new Cat();
var dog = new Dog();
cat.say();
dog.say();ফিডল এখানে (কনসোল আউটপুট দেখুন)।
ES6 অনুসারে আপনার যা প্রয়োজন তা পূরণ করতে আপনি জাভাস্ক্রিপ্ট ক্লাস এবং উত্তরাধিকার ব্যবহার করতে পারেন।
ECMAScript 2015-এ প্রবর্তিত জাভাস্ক্রিপ্ট ক্লাসগুলি জাভাস্ক্রিপ্টের বিদ্যমান প্রোটোটাইপ-ভিত্তিক উত্তরাধিকারের তুলনায় মূলত সিনট্যাকটিকাল চিনি।
তথ্যসূত্র: https://developer.mozilla.org/en-US/docs/Web/ জাভা স্ক্রিপ্ট / রেফারেন্স / ক্লাস
প্রথমত, আমরা আমাদের বিমূর্ত ক্লাসটি সংজ্ঞায়িত করি। এই শ্রেণিটি তাত্ক্ষণিকভাবে চালু করা যায় না, তবে বাড়ানো যেতে পারে। আমরা এমন ফাংশনগুলিও সংজ্ঞায়িত করতে পারি যা অবশ্যই এই শ্রেণীর সমস্ত শ্রেণিতে প্রয়োগ করা উচিত।
/**
* 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");
}
}এর পরে, আমরা আমাদের কংক্রিট ক্লাসগুলি তৈরি করতে পারি। এই ক্লাসগুলি বিমূর্ত শ্রেণীর সমস্ত ক্রিয়াকলাপ এবং আচরণের উত্তরাধিকারী হবে।
/**
* 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 {}এবং ফলাফল ...
// 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.আপনি কি এরকম কিছু বোঝাতে চাইছেন:
function Animal() {
//Initialization for all Animals
}
//Function and properties shared by all instances of Animal
Animal.prototype.init=function(name){
this.name=name;
}
Animal.prototype.say=function(){
alert(this.name + " who is a " + this.type + " says " + this.whattosay);
}
Animal.prototype.type="unknown";
function Cat(name) {
this.init(name);
//Make a cat somewhat unique
var s="";
for (var i=Math.ceil(Math.random()*7); i>=0; --i) s+="e";
this.whattosay="Me" + s +"ow";
}
//Function and properties shared by all instances of Cat
Cat.prototype=new Animal();
Cat.prototype.type="cat";
Cat.prototype.whattosay="meow";
function Dog() {
//Call init with same arguments as Dog was called with
this.init.apply(this,arguments);
}
Dog.prototype=new Animal();
Dog.prototype.type="Dog";
Dog.prototype.whattosay="bark";
//Override say.
Dog.prototype.say = function() {
this.openMouth();
//Call the original with the exact same arguments
Animal.prototype.say.apply(this,arguments);
//or with other arguments
//Animal.prototype.say.call(this,"some","other","arguments");
this.closeMouth();
}
Dog.prototype.openMouth=function() {
//Code
}
Dog.prototype.closeMouth=function() {
//Code
}
var dog = new Dog("Fido");
var cat1 = new Cat("Dash");
var cat2 = new Cat("Dot");
dog.say(); // Fido the Dog says bark
cat1.say(); //Dash the Cat says M[e]+ow
cat2.say(); //Dot the Cat says M[e]+ow
alert(cat instanceof Cat) // True
alert(cat instanceof Dog) // False
alert(cat instanceof Animal) // Truewhattosayমধ্যে সংজ্ঞায়িত করা হয় না পশু ), এবং এই উত্তরটি পরিষ্কারভাবে জিজ্ঞেস করে যে যদি প্রস্তাবিত উত্তরটি প্রশ্নকারীর সন্ধান করছিল তবে এটি জাভাস্ক্রিপ্টে বিমূর্ত শ্রেণীর জন্য কোনও সমাধান দেওয়ার দাবি করে না। প্রশ্নকারী আমার বা অন্য কারও কাছে জবাব দেওয়ার জন্য মাথা ঘামায় নি তাই এটি তার পক্ষে কাজ করে কিনা আমার কোনও ধারণা নেই। আমি দুঃখিত যদি কোনও এলিসের প্রশ্নের পাঁচ বছরের পুরানো প্রস্তাবিত উত্তরটি আপনার পক্ষে কার্যকর না হয়।
আপনি ডিন এডওয়ার্ডসের বেস ক্লাসটি চেক করতে চাইতে পারেন: http://dean.edwards.name/weblog/2006/03/base/
বিকল্পভাবে, জাভাস্ক্রিপ্টে শাস্ত্রীয় উত্তরাধিকার সম্পর্কে ডগলাস ক্রকফোর্ডের এই উদাহরণ / নিবন্ধটি রয়েছে: http://www.crockford.com/javascript/inheritance.html
জাভাস্ক্রিপ্টে অ্যাবস্ট্রাক্ট বেস ক্লাস অনুকরণ করা সম্ভব?
অবশ্যই. জাভাস্ক্রিপ্টে শ্রেণি / ইনস্ট্যান্স সিস্টেম প্রয়োগের প্রায় এক হাজার উপায় রয়েছে। এখানে একটি:
// 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 cat = নতুন প্রাণী ('বিড়াল');
এটি অবশ্যই একটি বিমূর্ত বেস ক্লাস নয়। আপনি কি এরকম কিছু বোঝাতে চাইছেন:
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!Animal = function () { throw "abstract class!" }
Animal.prototype.name = "This animal";
Animal.prototype.sound = "...";
Animal.prototype.say = function() {
console.log( this.name + " says: " + this.sound );
}
Cat = function () {
this.name = "Cat";
this.sound = "meow";
}
Dog = function() {
this.name = "Dog";
this.sound = "woof";
}
Cat.prototype = Object.create(Animal.prototype);
Dog.prototype = Object.create(Animal.prototype);
new Cat().say(); //Cat says: meow
new Dog().say(); //Dog says: woof
new Animal().say(); //Uncaught abstract class! 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();এটি __proto__কোনও স্ট্যান্ডার্ড ভেরিয়েবল নয় বলে কাজ করার গ্যারান্টিযুক্ত নয়, তবে এটি ফায়ারফক্স এবং সাফারিতে অন্তত কাজ করে।
এটি কীভাবে কাজ করে তা যদি আপনি বুঝতে না পারেন তবে প্রোটোটাইপ চেইন সম্পর্কে পড়ুন।
setPrototypeOf এখনও আমার এমন কোনও পদ্ধতি নেই যা আমার কোডের জন্য প্রয়োজন।
আপনি অবজেক্ট ক্লোটোগুলি অবজেক্ট প্রোটোটাইপ ব্যবহার করে তৈরি করতে পারেন, একটি সাধারণ উদাহরণ নিম্নরূপ হতে পারে:
var SampleInterface = {
addItem : function(item){}
}আপনি উপরের পদ্ধতিটি পরিবর্তন করতে পারেন বা না করতে পারেন, আপনি এটি প্রয়োগ করার সময় এটি আপনার উপর নির্ভর করে। বিস্তারিত পর্যবেক্ষণের জন্য, আপনি এখানে দেখতে চাইতে পারেন ।
প্রশ্নটি বেশ পুরানো, তবে আমি কীভাবে বিমূর্ত "শ্রেণি" তৈরি করতে এবং সেই ধরণের অবজেক্টের ব্লক সৃষ্টি কীভাবে তৈরি করতে পারি তার কিছু সম্ভাব্য সমাধান আমি তৈরি করেছি।
//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();আপনি দেখতে পাচ্ছেন সর্বশেষ অবজেক্টটি আমাদের ত্রুটি দেয়, কারণ প্রোটোটাইপের প্রাণীর সম্পত্তি রয়েছে abstract। Animal.prototypeপ্রোটোটাইপ শৃঙ্খলে আমি এটি করি এমন প্রাণীই নয় এটি নিশ্চিত হওয়ার জন্য :
Object.getPrototypeOf(this).hasOwnProperty("abstract")সুতরাং আমি পরীক্ষা করে দেখি যে আমার নিকটতম প্রোটোটাইপ অবজেক্টটির abstractসম্পত্তি রয়েছে, কেবল Animalপ্রোটোটাইপ থেকে সরাসরি তৈরি করা অবজেক্টের এই শর্তটি সত্য। ফাংশন hasOwnPropertyকেবলমাত্র তার প্রোটোটাইপগুলি নয় বর্তমান সামগ্রীর বৈশিষ্ট্যগুলি পরীক্ষা করে, তাই এটি আমাদের 100% নিশ্চিত করে যে সম্পত্তিটি এখানে প্রোটোটাইপ চেইনে ঘোষণা করা হয়নি।
অবজেক্ট থেকে উত্পন্ন প্রতিটি বস্তুর hasnwanProperty পদ্ধতি উত্তরাধিকার সূত্রে প্রাপ্ত । এই পদ্ধতিতে কোনও বস্তুর property বস্তুর প্রত্যক্ষ সম্পত্তি হিসাবে নির্দিষ্ট সম্পত্তি রয়েছে কিনা তা নির্ধারণ করতে ব্যবহার করা যেতে পারে; অপারেটরের বিপরীতে, এই পদ্ধতিটি অবজেক্টের প্রোটোটাইপ চেইনটি পরীক্ষা করে না। এটি সম্পর্কে আরও:
আমার প্রস্তাবনায় @ জর্দো এর বর্তমান সেরা উত্তরে এটির মতো constructorপ্রতিবার আমাদের পরিবর্তন করতে হবে না Object.create।
সমাধান হায়ারার্কিতে অনেক বিমূর্ত ক্লাস তৈরি করতে সক্ষম করে, আমাদের কেবল abstractপ্রোটোটাইপে সম্পত্তি তৈরি করতে হবে ।
আপনি প্রয়োগ করতে চাইছেন এমন আরও একটি জিনিস হ'ল আপনার বিমূর্ত শ্রেণিটি তাত্ক্ষণিকভাবে না তা নিশ্চিত করা making আপনি এমন কোনও ফাংশন সংজ্ঞায়নের মাধ্যমে এটি করতে পারেন যা অ্যাবস্ট্রাক্ট ক্লাস কনস্ট্রাক্টর হিসাবে সেট FLAG হিসাবে কাজ করে। এরপরে এটি এফএলএজি নির্মাণের চেষ্টা করবে যা তার কনস্ট্রাক্টরটিকে ব্যতিক্রমযুক্ত কলটিকে ডেকে ফেলবে। নীচে উদাহরণ:
(function(){
var FLAG_ABSTRACT = function(__class){
throw "Error: Trying to instantiate an abstract class:"+__class
}
var Class = function (){
Class.prototype.constructor = new FLAG_ABSTRACT("Class");
}
//will throw exception
var foo = new Class();
})()জাভাস্ক্রিপ্টের উত্তরাধিকার থাকতে পারে, নীচের URL টি দেখুন:
http://www.webreference.com/js/column79/
অ্যান্ড্রু
আমরা Factoryএক্ষেত্রে ডিজাইন প্যাটার্ন ব্যবহার করতে পারি । জাভাস্ক্রিপ্ট prototypeপিতামাতার সদস্যদের উত্তরাধিকারী হিসাবে ব্যবহার করুন ।
প্যারেন্ট ক্লাস কনস্ট্রাক্টর সংজ্ঞায়িত করুন।
var Animal = function() {
this.type = 'animal';
return this;
}
Animal.prototype.tired = function() {
console.log('sleeping: zzzZZZ ~');
}এবং তারপরে বাচ্চাদের ক্লাস তৈরি করুন।
// These are the child classes
Animal.cat = function() {
this.type = 'cat';
this.says = function() {
console.log('says: meow');
}
}তারপরে শিশু শ্রেণির নির্মাতা সংজ্ঞায়িত করুন।
// Define the child class constructor -- Factory Design Pattern.
Animal.born = function(type) {
// Inherit all members and methods from parent class,
// and also keep its own members.
Animal[type].prototype = new Animal();
// Square bracket notation can deal with variable object.
creature = new Animal[type]();
return creature;
}এটা পরীক্ষা করো.
var timmy = Animal.born('cat');
console.log(timmy.type) // cat
timmy.says(); // meow
timmy.tired(); // zzzZZZ~পুরো উদাহরণ কোডিংয়ের জন্য এখানে কোডেপ লিঙ্ক ।
//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!আমার মনে হয় এই সমস্ত উত্তরগুলি বিশেষত প্রথম দুটি ( কিছু এবং জর্ডো দ্বারা ) প্রচলিত প্রোটোটাইপ বেস জেএস ধারণার সাহায্যে প্রশ্নের স্পষ্ট উত্তর দেয়।
এখন আপনি যেমন চাইছেন প্রাণী শ্রেণীর নির্মাতা নির্মাণের পাশ করা প্যারামিটার অনুসারে আচরণ করুন, আমি মনে করি এটি অনেকটা Creational Patternsউদাহরণস্বরূপ ফ্যাক্টরি প্যাটার্নের বুনিয়াদী আচরণের সাথে সাদৃশ্যপূর্ণ ।
এখানে সেভাবে কাজ করার জন্য আমি কিছুটা পন্থা করেছি।
var Animal = function(type) {
this.type=type;
if(type=='dog')
{
return new Dog();
}
else if(type=="cat")
{
return new Cat();
}
};
Animal.prototype.whoAreYou=function()
{
console.log("I am a "+this.type);
}
Animal.prototype.say = function(){
console.log("Not implemented");
};
var Cat =function () {
Animal.call(this);
this.type="cat";
};
Cat.prototype=Object.create(Animal.prototype);
Cat.prototype.constructor = Cat;
Cat.prototype.say=function()
{
console.log("meow");
}
var Dog =function () {
Animal.call(this);
this.type="dog";
};
Dog.prototype=Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;
Dog.prototype.say=function()
{
console.log("bark");
}
var animal=new Animal();
var dog = new Animal('dog');
var cat=new Animal('cat');
animal.whoAreYou(); //I am a undefined
animal.say(); //Not implemented
dog.whoAreYou(); //I am a dog
dog.say(); //bark
cat.whoAreYou(); //I am a cat
cat.say(); //meowAnimalনির্মাণকারীটিকে একটি অ্যান্টি-প্যাটার্ন হিসাবে দেখা যেতে পারে, একটি সুপারক্লাসের সাবক্লাস সম্পর্কে জ্ঞান থাকা উচিত নয়। (লিসকভ এবং ওপেন / ক্লোজ নীতি লঙ্ঘন করে)
/****************************************/
/* 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();আপনি যদি নিশ্চিত করতে চান যে এখানে আপনার বেস ক্লাস এবং তাদের সদস্যগণ কঠোরভাবে বিমূর্ত রয়েছে এটি একটি বেস ক্লাস যা এটি আপনার জন্য করে:
class AbstractBase{
constructor(){}
checkConstructor(c){
if(this.constructor!=c) return;
throw new Error(`Abstract class ${this.constructor.name} cannot be instantiated`);
}
throwAbstract(){
throw new Error(`${this.constructor.name} must implement abstract member`);}
}
class FooBase extends AbstractBase{
constructor(){
super();
this.checkConstructor(FooBase)}
doStuff(){this.throwAbstract();}
doOtherStuff(){this.throwAbstract();}
}
class FooBar extends FooBase{
constructor(){
super();}
doOtherStuff(){/*some code here*/;}
}
var fooBase = new FooBase(); //<- Error: Abstract class FooBase cannot be instantiated
var fooBar = new FooBar(); //<- OK
fooBar.doStuff(); //<- Error: FooBar must implement abstract member
fooBar.doOtherStuff(); //<- OKস্ট্রাইক মোড থ্রো অস্ট্রাক্ট পদ্ধতিতে কলারটিকে লগ করা অসম্ভব করে তোলে তবে কোনও ত্রুটি একটি ডিবাগ পরিবেশে হওয়া উচিত যা স্ট্যাকের চিহ্নটি দেখায়।