জাভাস্ক্রিপ্ট ক্লাস / অবজেক্টে কি কনস্ট্রাক্টর থাকতে পারে? তারা কিভাবে তৈরি হয়?
উত্তর:
প্রোটোটাইপ ব্যবহার:
function Box(color) // Constructor
{
this.color = color;
}
Box.prototype.getColor = function()
{
return this.color;
};"রঙ" লুকানো (কিছুটা ব্যক্তিগত সদস্যের ভেরিয়েবলের অনুরূপ):
function Box(col)
{
var color = col;
this.getColor = function()
{
return color;
};
}ব্যবহার:
var blueBox = new Box("blue");
alert(blueBox.getColor()); // will alert blue
var greenBox = new Box("green");
alert(greenBox.getColor()); // will alert greencolor। আমি আপনাকে যা ব্যবহার করব তা ব্যক্তিগত পছন্দ অনুসারে (সুরক্ষা বনাম সরলতা)
varএকটি ব্যক্তিগত পরিবর্তনশীল করে তোলে। thisএকটি সর্বজনীন পরিবর্তনশীল করে তোলে
Foo, যদিও পরবর্তী ক্ষেত্রে এটি জানতে পারবে যে এটি Fooডাকা হচ্ছে। ডিবাগিংয়ের জন্য খুব সহায়ক।
আমি কখনও কখনও জাভাস্ক্রিপ্টে ওওপি-অনুরূপ আচরণের জন্য ব্যবহার করি এমন একটি টেম্পলেট। আপনি দেখতে পাচ্ছেন, ক্লোজারগুলি ব্যবহার করে আপনি ব্যক্তিগত (স্থির এবং উদাহরণ উভয়) সদস্যদের অনুকরণ করতে পারেন। কী new MyClass()ফিরে আসবে তা কেবলমাত্র বস্তুর জন্য নির্ধারিত বৈশিষ্ট্য thisএবং prototype"শ্রেণীর" অবজেক্টের সাথে যুক্ত is
var MyClass = (function () {
// private static
var nextId = 1;
// constructor
var cls = function () {
// private
var id = nextId++;
var name = 'Unknown';
// public (this instance only)
this.get_id = function () { return id; };
this.get_name = function () { return name; };
this.set_name = function (value) {
if (typeof value != 'string')
throw 'Name must be a string';
if (value.length < 2 || value.length > 20)
throw 'Name must be 2-20 characters long.';
name = value;
};
};
// public static
cls.get_nextId = function () {
return nextId;
};
// public (shared across instances)
cls.prototype = {
announce: function () {
alert('Hi there! My id is ' + this.get_id() + ' and my name is "' + this.get_name() + '"!\r\n' +
'The next fellow\'s id will be ' + MyClass.get_nextId() + '!');
}
};
return cls;
})();আমাকে এই নিদর্শনটি ব্যবহার করে উত্তরাধিকার সম্পর্কে জিজ্ঞাসা করা হয়েছে, সুতরাং এখানে যায়:
// It's a good idea to have a utility class to wire up inheritance.
function inherit(cls, superCls) {
// We use an intermediary empty constructor to create an
// inheritance chain, because using the super class' constructor
// might have side effects.
var construct = function () {};
construct.prototype = superCls.prototype;
cls.prototype = new construct;
cls.prototype.constructor = cls;
cls.super = superCls;
}
var MyChildClass = (function () {
// constructor
var cls = function (surName) {
// Call super constructor on this instance (any arguments
// to the constructor would go after "this" in call(…)).
this.constructor.super.call(this);
// Shadowing instance properties is a little bit less
// intuitive, but can be done:
var getName = this.get_name;
// public (this instance only)
this.get_name = function () {
return getName.call(this) + ' ' + surName;
};
};
inherit(cls, MyClass); // <-- important!
return cls;
})();এবং এটি সমস্ত ব্যবহার করার জন্য একটি উদাহরণ:
var bob = new MyClass();
bob.set_name('Bob');
bob.announce(); // id is 1, name shows as "Bob"
var john = new MyChildClass('Doe');
john.set_name('John');
john.announce(); // id is 2, name shows as "John Doe"
alert(john instanceof MyClass); // trueআপনি দেখতে পাচ্ছেন, ক্লাসগুলি একে অপরের সাথে সঠিকভাবে যোগাযোগ করে (তারা স্ট্যাটিক আইডিটি ভাগ করে MyClassদেয়, announceপদ্ধতিটি সঠিক get_nameপদ্ধতি ব্যবহার করে ))
একটি বিষয় লক্ষণীয় হ'ল উদাহরণের বৈশিষ্ট্যগুলির ছায়া নেওয়া। আপনি কার্যত inheritফাংশনটি সমস্ত উদাহরণ বৈশিষ্ট্য (ব্যবহার করে hasOwnProperty) যা ফাংশনগুলিতে যেতে পারেন এবং স্বয়ংক্রিয়ভাবে কোনও super_<method name>সম্পত্তি যুক্ত করতে পারেন। এটি আপনাকে this.super_get_name()অস্থায়ী মান হিসাবে সঞ্চয় করার পরিবর্তে এবং কলটি ব্যবহার করে কল করার পরিবর্তে কল করতে দেয় call।
প্রোটোটাইপের পদ্ধতিগুলির জন্য আপনাকে উপরের বিষয়ে চিন্তা করার দরকার নেই, আপনি যদি সুপার ক্লাসের প্রোটোটাইপ পদ্ধতিগুলি অ্যাক্সেস করতে চান তবে আপনি কেবল কল করতে পারেন this.constructor.super.prototype.methodName। আপনি যদি এটি কম ভার্বোস করতে চান তবে অবশ্যই সুবিধার বৈশিষ্ট্য যুক্ত করতে পারেন। :)
cls.prototypeঅংশটি সম্পর্কে কেবল একটি নোট : "উদাহরণগুলি জুড়ে ভাগ করা" কেবল মূল্য (কলিং announce) পড়ার জন্য । আপনি যদি myClassInstance.announceঅন্য কোনও মান সেট করে থাকেন তবে এটি একটি নতুন সম্পত্তি তৈরি করে myClassInstance, সুতরাং এটি কেবলমাত্র সেই বস্তুর জন্য প্রযোজ্য, শ্রেণীর অন্যান্য উদাহরণ নয়। নিযুক্ত করা MyClass.prototype.announceসমস্ত দৃষ্টান্তগুলিকে প্রভাবিত করবে।
MyClass.get_nextId()
আমার কাছে মনে হচ্ছে আপনারা বেশিরভাগ গ্রাহক এবং সেটারের উদাহরণ দিচ্ছেন কোনও নির্মাণকারী নয়, যেমন http://en.wikedia.org/wiki/Constructor_(object-oriented_programming) ।
মধ্যাহ্নভোজ-ডান কাছাকাছি ছিল তবে উদাহরণটি জেএসফিডেলে কাজ করে নি।
এই উদাহরণটি একটি প্রাইভেট কনস্ট্রাক্টর ফাংশন তৈরি করে যা কেবলমাত্র অবজেক্ট তৈরির সময় চলতে পারে।
var color = 'black';
function Box()
{
// private property
var color = '';
// private constructor
var __construct = function() {
alert("Object Created.");
color = 'green';
}()
// getter
this.getColor = function() {
return color;
}
// setter
this.setColor = function(data) {
color = data;
}
}
var b = new Box();
alert(b.getColor()); // should be green
b.setColor('orange');
alert(b.getColor()); // should be orange
alert(color); // should be blackআপনি যদি সর্বজনীন বৈশিষ্ট্য বরাদ্দ করতে চেয়েছিলেন তবে কনস্ট্রাক্টর হিসাবে এটি নির্ধারণ করা যেতে পারে:
var color = 'black';
function Box()
{
// public property
this.color = '';
// private constructor
var __construct = function(that) {
alert("Object Created.");
that.color = 'green';
}(this)
// getter
this.getColor = function() {
return this.color;
}
// setter
this.setColor = function(color) {
this.color = color;
}
}
var b = new Box();
alert(b.getColor()); // should be green
b.setColor('orange');
alert(b.getColor()); // should be orange
alert(color); // should be blackBox()কার্যকারিতা হিসাবে কোনও পরামিতি নেই :)। তবে এই উদাহরণের পাশাপাশি অন্যান্য উত্তরের উদাহরণগুলি প্যারামিটারগুলি গ্রহণ করতে সহজতর প্রসারিত হতে পারে।
Boxফাংশনে কেবল আপনার নির্মাণ করুন এবং আপনি যেতে ভাল (এটি এখনও "ব্যক্তিগত")। জাভাস্ক্রিপ্টে "প্রাইভেট" এর অর্থ লেক্সিকাল স্কোপের মাধ্যমে অ্যাক্সেসযোগ্য; সদস্যদের নিয়োগের দরকার নেই। অতিরিক্তভাবে: এই কোডটি ভুল। এটি একটি বৈশ্বিক __constructপরিবর্তনশীল তৈরি করে , যা বেশ খারাপ। varএর পরিধি সীমাবদ্ধ করতে ব্যবহার করা উচিত __construct।
তাহলে "কনস্ট্রাক্টর" প্রপার্টিটি কী? এটি কোথায় কার্যকর হতে পারে তা অনুমান করা যায় না, কোনও ধারণা?
কনস্ট্রাক্টর প্রোপার্টিটির বিন্দুটি জাভাস্ক্রিপ্টের ভান করার কয়েকটি উপায় সরবরাহ করা ক্লাস রয়েছে। একটি জিনিস যা আপনি পারবেন না কার্যকরভাবে তা হ'ল কোনও অবজেক্টের কনস্ট্রাক্টর তৈরি হওয়ার পরে পরিবর্তন করা। এটা জটিল.
আমি কয়েক বছর আগে এটিতে একটি মোটামুটি বিস্তৃত টুকরো লিখেছি: http://joost.zeekat.nl/constructors-considered-mildly-confusing.html
উদাহরণ এখানে: http://jsfiddle.net/FZ5nC/
এই টেমপ্লেটটি ব্যবহার করে দেখুন:
<script>
//============================================================
// Register Namespace
//------------------------------------------------------------
var Name = Name||{};
Name.Space = Name.Space||{};
//============================================================
// Constructor - MUST BE AT TOP OF FILE
//------------------------------------------------------------
Name.Space.ClassName = function Name_Space_ClassName(){}
//============================================================
// Member Functions & Variables
//------------------------------------------------------------
Name.Space.ClassName.prototype = {
v1: null
,v2: null
,f1: function Name_Space_ClassName_f1(){}
}
//============================================================
// Static Variables
//------------------------------------------------------------
Name.Space.ClassName.staticVar = 0;
//============================================================
// Static Functions
//------------------------------------------------------------
Name.Space.ClassName.staticFunc = function Name_Space_ClassName_staticFunc(){
}
</script>আপনি যদি কোনও স্থির শ্রেণীর সংজ্ঞা দিচ্ছেন তবে আপনাকে অবশ্যই নিজের নাম স্থানটি ঠিক করতে হবে:
<script>
//============================================================
// Register Namespace
//------------------------------------------------------------
var Shape = Shape||{};
Shape.Rectangle = Shape.Rectangle||{};
// In previous example, Rectangle was defined in the constructor.
</script>উদাহরণ শ্রেণি:
<script>
//============================================================
// Register Namespace
//------------------------------------------------------------
var Shape = Shape||{};
//============================================================
// Constructor - MUST BE AT TOP OF FILE
//------------------------------------------------------------
Shape.Rectangle = function Shape_Rectangle(width, height, color){
this.Width = width;
this.Height = height;
this.Color = color;
}
//============================================================
// Member Functions & Variables
//------------------------------------------------------------
Shape.Rectangle.prototype = {
Width: null
,Height: null
,Color: null
,Draw: function Shape_Rectangle_Draw(canvasId, x, y){
var canvas = document.getElementById(canvasId);
var context = canvas.getContext("2d");
context.fillStyle = this.Color;
context.fillRect(x, y, this.Width, this.Height);
}
}
//============================================================
// Static Variables
//------------------------------------------------------------
Shape.Rectangle.Sides = 4;
//============================================================
// Static Functions
//------------------------------------------------------------
Shape.Rectangle.CreateSmallBlue = function Shape_Rectangle_CreateSmallBlue(){
return new Shape.Rectangle(5,8,'#0000ff');
}
Shape.Rectangle.CreateBigRed = function Shape_Rectangle_CreateBigRed(){
return new Shape.Rectangle(50,25,'#ff0000');
}
</script>উদাহরণ ইনস্ট্যান্টেশন:
<canvas id="painting" width="500" height="500"></canvas>
<script>
alert("A rectangle has "+Shape.Rectangle.Sides+" sides.");
var r1 = new Shape.Rectangle(16, 12, "#aa22cc");
r1.Draw("painting",0, 20);
var r2 = Shape.Rectangle.CreateSmallBlue();
r2.Draw("painting", 0, 0);
Shape.Rectangle.CreateBigRed().Draw("painting", 10, 0);
</script>নোটিশ ফাংশনগুলি AB = ফাংশন A_B () হিসাবে সংজ্ঞায়িত করা হয়। এটি আপনার স্ক্রিপ্টটি ডিবাগ করা সহজতর করার জন্য। Chrome এর পরিদর্শনকারী এলিমেন্ট প্যানেলটি খুলুন, এই স্ক্রিপ্টটি চালান, এবং ডিবাগ ব্যাকট্রেস প্রসারিত করুন:
<script>
//============================================================
// Register Namespace
//------------------------------------------------------------
var Fail = Fail||{};
//============================================================
// Static Functions
//------------------------------------------------------------
Fail.Test = function Fail_Test(){
A.Func.That.Does.Not.Exist();
}
Fail.Test();
</script>এটি একটি নির্মাতা:
function MyClass() {}যখন তুমি কর
var myObj = new MyClass();MyClass মৃত্যুদন্ড কার্যকর করা হয় এবং সেই শ্রেণীর একটি নতুন অবজেক্ট ফিরে আসে।
alert(valuePassedInAsArgument);এবং এটি প্রতিটি ইনস্ট্যান্টেশনের জন্য একবার চালানো হবে, তাই পুরো ক্লাসটি নিজেই নির্মাতা।
new object is returned of that class- এটি কি নতুন ফাংশনটি দিয়ে কোনও নতুন জিনিস ফেরত দেওয়ার মতো নয়?
আমি এই টিউটোরিয়ালটি খুব দরকারী বলে মনে করি। এই পদ্ধতির বেশিরভাগ jQuery প্লাগইনগুলি ব্যবহার করে by
var Class = function(methods) {
var klass = function() {
this.initialize.apply(this, arguments);
};
for (var property in methods) {
klass.prototype[property] = methods[property];
}
if (!klass.prototype.initialize) klass.prototype.initialize = function(){};
return klass;
};এখন,
var Person = Class({
initialize: function(name, age) {
this.name = name;
this.age = age;
},
toString: function() {
return "My name is "+this.name+" and I am "+this.age+" years old.";
}
});
var alice = new Person('Alice', 26);
alert(alice.name); //displays "Alice"
alert(alice.age); //displays "26"
alert(alice.toString()); //displays "My name is Alice and I am 26 years old" in most browsers.
//IE 8 and below display the Object's toString() instead! "[Object object]"klass
এই প্যাটার্নটি আমাকে ভালভাবে পরিবেশন করেছে। এই নিদর্শন দিয়ে, আপনি পৃথক ফাইলগুলিতে ক্লাস তৈরি করেন, আপনার সামগ্রিক অ্যাপ্লিকেশনটিতে "প্রয়োজনীয় হিসাবে" লোড করুন।
// Namespace
// (Creating new if not instantiated yet, otherwise, use existing and just add to it)
var myApp = myApp || {};
// "Package"
// Similar to how you would establish a package in other languages
(function() {
// "Class"
var MyClass = function(params) {
this.initialize(params);
}
// "Private Static" vars
// - Only accessible to functions in this class.
// - Doesn't get wiped out when we create a new instance.
var countInstances = 0;
var allInstances = [];
// "Private Static" functions
// - Same as above, but it's a function accessible
// only to other functions in this class.
function doSomething(){
}
// "Public Static" vars
// - Everyone has access.
// - Doesn't get wiped out when we create a new instance.
MyClass.counter = 0;
// "Public Static" functions
// - Same as above, but anyone can call this "static method".
// - Kinda like a singleton class situation.
MyClass.foobar = function(){
}
// Public properties and methods are built into the "prototype"
// - This is how each instance can become unique unto itself.
// - Establishing "p" as "local" (Static Private) variable
// simply so we don't have to keep typing "MyClass.prototype"
// for each property and function.
var p = MyClass.prototype;
// "Public" vars
p.id = null;
p.firstname = null;
p.lastname = null;
// "Private" vars
// - Only used by "this" instance.
// - There isn't "true" privacy for each
// instance so we have to fake it.
// - By tradition, we indicate "privacy"
// by prefixing it with an underscore.
// - So technically, anyone can access, but we simply
// don't tell anyone about it (e.g. in your API)
// so no one knows about it :)
p._foo = null;
p.initialize = function(params){
this.id = MyClass.counter++;
this.firstname = params.firstname;
this.lastname = params.lastname;
MyClass.counter++;
countInstances++;
allInstances.push(this);
}
p.doAlert = function(theMessage){
alert(this.firstname + " " + this.lastname + " said: " + theMessage + ". My id:" + this.id + ". Total People:" + countInstances + ". First Person:" + allInstances[0].firstname + " " + allInstances[0].lastname);
}
// Assign class to app
myApp.MyClass = MyClass;
// Close the "Package"
}());
// Usage example:
var bob = new myApp.MyClass({ firstname : "bob",
lastname : "er"
});
bob.doAlert("hello there");varকনস্ট্রাক্টরের স্থানীয় (বা ফাংশন আর্গুমেন্ট, বা কনস্ট্রাক্টরের মতো ফাংশন)।
হ্যাঁ, আপনি শ্রেণি ঘোষণার ভিতরে কোনও কনস্ট্রাক্টর সংজ্ঞায়িত করতে পারেন:
class Rectangle {
constructor(height, width) {
this.height = height;
this.width = width;
}
}আমার ধারণা আমি জাভাস্ক্রিপ্ট বন্ধের সাথে যা করব তা পোস্ট করব যেহেতু কেউ এখনও ক্লোজার ব্যবহার করছে না।
var user = function(id) {
// private properties & methods goes here.
var someValue;
function doSomething(data) {
someValue = data;
};
// constructor goes here.
if (!id) return null;
// public properties & methods goes here.
return {
id: id,
method: function(params) {
doSomething(params);
}
};
};এই সমাধান সম্পর্কে মন্তব্য এবং পরামর্শ স্বাগত। :)
উপরের নিকের নমুনা ব্যবহার করে, আপনি আপনার অবজেক্টের সংজ্ঞাতে সর্বশেষ বিবৃতি হিসাবে রিটার্ন স্টেটমেন্ট ব্যবহার করে প্যারামিটার ছাড়াই অবজেক্টের জন্য কনস্ট্রাক্টর তৈরি করতে পারেন । আপনার কন্সট্রাক্টর ফাংশনটি নীচের মত করে ফিরিয়ে দিন এবং আপনি যখনই বস্তুটি তৈরি করবেন তখন কোডটি __ কনস্ট্রাক্টে চলবে:
function Box()
{
var __construct = function() {
alert("Object Created.");
this.color = 'green';
}
this.color = '';
this.getColor = function() {
return this.color;
}
__construct();
}
var b = new Box();this.getColor();উপরের লাইনে ব্যবহার করার চেষ্টা করেন তবে alert("Object Created.");কিছুই সতর্ক করা হবে না। "GetColor সংজ্ঞায়িত করা হয়নি" এর মতো একটি ত্রুটি থাকবে। আপনি যদি কনস্ট্রাক্টটিকে অবজেক্টে অন্য পদ্ধতিগুলি কল করতে সক্ষম করতে চান তবে এটি অন্যান্য সমস্ত পদ্ধতির পরে সংজ্ঞায়িত করা দরকার। সুতরাং __construct();শেষ লাইনে কল করার পরিবর্তে কেবল সেখানে নির্ধারিত সংজ্ঞা নির্ধারণ করুন এবং ()এটি অটো-এক্সিকিউট করতে বাধ্য করার জন্য এটি রাখুন।
()__ কনস্ট্রাক্ট সংজ্ঞাটির শেষে যুক্ত করার পরেও ত্রুটির ফলস্বরূপ। __construct();ত্রুটি এড়াতে আমাকে মূল কোডের মতো নিজস্ব লাইনে কল করতে হয়েছিল।
সম্ভবত এটি কিছুটা সহজসাধ্য হয়ে উঠেছে, তবে নীচে আমি এখন 2017 এ নিয়ে এসেছি:
class obj {
constructor(in_shape, in_color){
this.shape = in_shape;
this.color = in_color;
}
getInfo(){
return this.shape + ' and ' + this.color;
}
setShape(in_shape){
this.shape = in_shape;
}
setColor(in_color){
this.color = in_color;
}
}উপরের ক্লাসটি ব্যবহার করার জন্য, আমার কাছে নিম্নলিখিতগুলি রয়েছে:
var newobj = new obj('square', 'blue');
//Here, we expect to see 'square and blue'
console.log(newobj.getInfo());
newobj.setColor('white');
newobj.setShape('sphere');
//Since we've set new color and shape, we expect the following: 'sphere and white'
console.log(newobj.getInfo());আপনি দেখতে পাচ্ছেন, কনস্ট্রাক্টর দুটি পরামিতি নেয় এবং আমরা বস্তুর বৈশিষ্ট্যগুলি সেট করি। আমরা setterফাংশনগুলি ব্যবহার করে অবজেক্টের রঙ এবং আকার পরিবর্তন করি এবং প্রমাণ করি যে এটির পরিবর্তনটি কল করার পরেও রয়েছেgetInfo() এই পরিবর্তনগুলি পরে এই পরিবর্তনটি আনা হয়েছে।
কিছুটা দেরি হলেও আমি আশা করি এটি সাহায্য করবে। আমি এটি mochaইউনিট-পরীক্ষার মাধ্যমে পরীক্ষা করেছি এবং এটি ভালভাবে কাজ করছে।
আপনি যদি টাইপস্ক্রিপ্ট ব্যবহার করেন - মাইক্রোসফ্ট থেকে মুক্ত উত্স :-)
class BankAccount {
balance: number;
constructor(initially: number) {
this.balance = initially;
}
deposit(credit: number) {
this.balance += credit;
return this.balance;
}
}টাইপস্ক্রিপ্ট আপনাকে জাভাস্ক্রিপ্ট কনস্ট্রাক্টসগুলিতে সংকলিত 'জাল' ওও কনস্ট্রাক্টসগুলি দেয় lets যদি আপনি একটি বড় প্রকল্প শুরু করেন তবে এটি আপনাকে অনেক সময় সাশ্রয় করতে পারে এবং এটি সবেমাত্র মাইলফলক 1.0 সংস্করণে পৌঁছেছে।
http://www.typescriptlang.org/Content/TypeScript%20Language%20Specification.pdf
উপরের কোডটি এতে 'সংকলিত' হয়:
var BankAccount = (function () {
function BankAccount(initially) {
this.balance = initially;
}
BankAccount.prototype.deposit = function (credit) {
this.balance += credit;
return this.balance;
};
return BankAccount;
})();জাভাস্ক্রিপ্টে অনুরোধের ধরণটি ফাংশনের আচরণের সংজ্ঞা দেয়:
func()obj.func()new func()func.call() বাfunc.apply()ফাংশনটি একটি হিসাবে আহবান করা হয়েছে newঅপারেটর ব্যবহার করে কল করার সময় কনস্ট্রাক্টর ডাকা হয় :
function Cat(name) {
this.name = name;
}
Cat.prototype.getName = function() {
return this.name;
}
var myCat = new Cat('Sweet'); // Cat function invoked as a constructorজাভাস্ক্রিপ্টে কোনও উদাহরণ বা প্রোটোটাইপ অবজেক্টের একটি সম্পত্তি রয়েছে constructorযা কনস্ট্রাক্টর ফাংশনকে বোঝায়।
Cat.prototype.constructor === Cat // => true
myCat.constructor === Cat // => trueনির্মাণকারী সম্পত্তি সম্পর্কে এই পোস্টটি দেখুন ।
উপরে থেকে ব্ল্যাক্স্টের দুর্দান্ত টেম্পলেটটি ব্যবহার করার সময়, আমি জানতে পেরেছিলাম যে এটি বহু-স্তরের উত্তরাধিকার (মাইগ্র্যান্ডচিল্ড ক্লাস মাইচিল্ড ক্লাস বাড়ানো মাইক্ল্যাডস প্রসারিত) - এটি প্রথম পিতামাতার কনস্ট্রাক্টরকে বারবার কল করার উপর চক্র করে। সুতরাং এখানে একটি সাধারণ কর্মসংস্থান - যদি আপনার এই জাতীয় সংজ্ঞাযুক্ত চেইন ফাংশনটি this.constructor.super.call(this, surName);ব্যবহার না করে একাধিক স্তরের উত্তরাধিকারের প্রয়োজন হয় chainSuper(this).call(this, surName);:
function chainSuper(cls) {
if (cls.__depth == undefined) cls.__depth = 1; else cls.__depth++;
var depth = cls.__depth;
var sup = cls.constructor.super;
while (depth > 1) {
if (sup.super != undefined) sup = sup.super;
depth--;
}
return sup;
}http://www.jsoops.net/ জেএস-এ ওওপের জন্য বেশ ভাল। যদি ব্যক্তিগত, সুরক্ষিত, পাবলিক ভেরিয়েবল এবং ফাংশন এবং উত্তরাধিকার বৈশিষ্ট্য সরবরাহ করে। উদাহরণ কোড:
var ClassA = JsOops(function (pri, pro, pub)
{// pri = private, pro = protected, pub = public
pri.className = "I am A ";
this.init = function (var1)// constructor
{
pri.className += var1;
}
pub.getData = function ()
{
return "ClassA(Top=" + pro.getClassName() + ", This=" + pri.getClassName()
+ ", ID=" + pro.getClassId() + ")";
}
pri.getClassName = function () { return pri.className; }
pro.getClassName = function () { return pri.className; }
pro.getClassId = function () { return 1; }
});
var newA = new ClassA("Class");
//***Access public function
console.log(typeof (newA.getData));
// function
console.log(newA.getData());
// ClassA(Top=I am A Class, This=I am A Class, ID=1)
//***You can not access constructor, private and protected function
console.log(typeof (newA.init)); // undefined
console.log(typeof (newA.className)); // undefined
console.log(typeof (newA.pro)); // undefined
console.log(typeof (newA.getClassName)); // undefinedশুধু কিছু বিভিন্ন অফার। জাভাস্ক্রিপ্টে কনস্ট্রাক্টর সহ ক্লাস ঘোষণার জন্য ডিএস.ওপ একটি দুর্দান্ত উপায়। এটি প্রতিটি সম্ভাব্য প্রকারের উত্তরাধিকারকে সমর্থন করে (এমন এক ধরণের সহ যা সি # সমর্থন করে না) পাশাপাশি ইন্টারফেসগুলিও দুর্দান্ত।
var Color = ds.make.class({
type: 'Color',
constructor: function (r,g,b) {
this.r = r; /* now r,g, and b are available to */
this.g = g; /* other methods in the Color class */
this.b = b;
}
});
var red = new Color(255,0,0); // using the new keyword to instantiate the classএখানে জাভা স্ক্রিপ্টের আমাদের একটি পয়েন্টটি লক্ষ্য করা দরকার, এটি একটি শ্রেণি-কম ভাষা, তবে জাভা স্ক্রিপ্টে ফাংশন ব্যবহার করে আমরা এটি অর্জন করতে পারি। এটি অর্জনের সর্বাধিক সাধারণ উপায় আমাদের জাভা স্ক্রিপ্টে একটি ক্রিয়াকলাপ তৈরি করতে হবে এবং একটি বস্তু তৈরি করতে নতুন কীওয়ার্ড ব্যবহার করতে হবে এবং সম্পত্তি এবং পদ্ধতিগুলি সংজ্ঞায়িত করতে এই কীওয়ার্ডটি ব্যবহার করতে হবে el নীচের উদাহরণটি।
// Function constructor
var calculator=function(num1 ,num2){
this.name="This is function constructor";
this.mulFunc=function(){
return num1*num2
};
};
var objCal=new calculator(10,10);// This is a constructor in java script
alert(objCal.mulFunc());// method call
alert(objCal.name);// property call
//Constructors With Prototypes
var calculator=function(){
this.name="Constructors With Prototypes";
};
calculator.prototype.mulFunc=function(num1 ,num2){
return num1*num2;
};
var objCal=new calculator();// This is a constructor in java script
alert(objCal.mulFunc(10,10));// method call
alert(objCal.name); // property callবেশিরভাগ ক্ষেত্রে আপনাকে এই পদ্ধতিতে পাস হওয়া কোনও পদ্ধতিতে কল করার আগে আপনার প্রয়োজনীয় সম্পত্তিটি কোনওভাবে ঘোষণা করতে হবে। যদি আপনাকে প্রাথমিকভাবে কোনও সম্পত্তি সেট করতে না হয় তবে আপনি কেবলমাত্র অবজেক্টের মধ্যে কোনও পদ্ধতিতে কল করতে পারেন। সম্ভবত এটি করার সবচেয়ে সুন্দর উপায় নয় তবে এটি এখনও কাজ করে।
var objectA = {
color: '';
callColor : function(){
console.log(this.color);
}
this.callColor();
}
var newObject = new objectA();