জাভাস্ক্রিপ্টে সিঙ্গেলটন প্যাটার্ন বাস্তবায়নের সহজ / পরিষ্কারতম উপায় কী?
জাভাস্ক্রিপ্টে সিঙ্গেলটন প্যাটার্ন বাস্তবায়নের সহজ / পরিষ্কারতম উপায় কী?
উত্তর:
আমি মনে করি সহজ উপায় হ'ল একটি সাধারণ বস্তুকে আক্ষরিক ঘোষণা করা:
var myInstance = {
method1: function () {
// ...
},
method2: function () {
// ...
}
};
আপনি যদি আপনার সিঙ্গলটনের উদাহরণে ব্যক্তিগত সদস্যদের চান, আপনি এই জাতীয় কিছু করতে পারেন:
var myInstance = (function() {
var privateVar = '';
function privateMethod () {
// ...
}
return { // public interface
publicMethod1: function () {
// all private members are accessible here
},
publicMethod2: function () {
}
};
})();
এটিকে মডিউল প্যাটার্ন বলা হয় , এটি ক্লোজার ব্যবহারের সুবিধা গ্রহণ করে মূলত আপনাকে কোনও বস্তুর মধ্যে ব্যক্তিগত সদস্যদের সজ্জিত করতে দেয় ।
আপডেট: আমি যুক্ত করতে চাই যে আপনি যদি সিঙ্গলটন অবজেক্টের পরিবর্তন রোধ করতে চান তবে আপনি এটিকে হিম করতে পারেন ES5 ব্যবহার করেObject.freeze
পদ্ধতি।
এটি অবজেক্টটিকে স্থাবর করে তুলবে, এর কাঠামো এবং মানগুলিতে কোনও পরিবর্তন রোধ করবে।
অতিরিক্ত হিসাবে আমি উল্লেখ করতে চাই যে আপনি যদি ES6 ব্যবহার করছেন তবে আপনি খুব সহজেই ES মডিউলগুলি ব্যবহার করে একটি সিঙ্গলটনের প্রতিনিধিত্ব করতে পারেন, এবং এমনকি আপনি মডিউল স্কোপে ভেরিয়েবলগুলি ঘোষণা করে ব্যক্তিগত রাষ্ট্রও ধরে রাখতে পারেন :
// my-singleton.js
const somePrivateState = []
function privateFn () {
// ...
}
export default {
method1() {
// ...
},
method2() {
// ...
}
}
তারপরে আপনি এটি ব্যবহার করার জন্য কেবল সিঙ্গলটন অবজেক্টটি আমদানি করতে পারেন:
import myInstance from './my-singleton.js'
// ...
publicMethod1
ডাকবে কীভাবে publicMethod2
?
getInstance
পদ্ধতি এবং একটি প্রাইভেট কনস্ট্রাক্টরের সাথে জড়িত - তবে আইএমও, এটি একটি সিঙ্গেলটন অবজেক্ট তৈরির সবচেয়ে "সহজ" উপায় জাভাস্ক্রিপ্টে, এবং শেষে এটি একই উদ্দেশ্যটির সাথে মিলিত হয় - একটি একক অবজেক্টের, আপনি আবার আরম্ভ করতে পারবেন না (কোনও নির্মাণকারী নেই, এটি কেবল একটি বস্তু) -। আপনি যে কোডটি লিঙ্ক সম্পর্কে, এটা কিছু সমস্যা রয়েছে অদলবদল a
এবং b
পরিবর্তনশীল ঘোষণা এবং পরীক্ষা a === window
। চিয়ার্স।
আমি মনে করি সবচেয়ে পরিষ্কার পদ্ধতির মত কিছু:
var SingletonFactory = (function(){
function SingletonClass() {
//do stuff
}
var instance;
return {
getInstance: function(){
if (instance == null) {
instance = new SingletonClass();
// Hide the constructor so the returned object can't be new'd...
instance.constructor = null;
}
return instance;
}
};
})();
পরে, আপনি হিসাবে ফাংশন প্রার্থনা করতে পারেন
var test = SingletonFactory.getInstance();
delete instance.constructor
:x = SingletonClass.getInstance();delete x.constructor;new x.constructor;
আমি নিশ্চিত নই যে আমি একটি একক প্যাটার্নের প্রতিস্থাপন হিসাবে মডিউল প্যাটার্নটি ব্যবহার করা হচ্ছে তাতে আমি একমত। আমি প্রায়শই সিঙ্গলেটগুলি এমন জায়গাগুলিতে ব্যবহৃত এবং অপব্যবহার দেখেছি যেখানে তারা সম্পূর্ণ অপ্রয়োজনীয়, এবং আমি নিশ্চিত যে মডিউল প্যাটার্নটি অনেক ফাঁক পূরণ করে যেখানে প্রোগ্রামাররা অন্যথায় একটি সিঙ্গলটন ব্যবহার করবে, তবে মডিউল প্যাটার্নটি এটি নয় একটি Singleton।
var foo = (function () {
"use strict";
function aPrivateFunction() {}
return { aPublicFunction: function () {...}, ... };
}());
মডিউল প্যাটার্নে সূচনা করা সমস্ত কিছু যখন ঘটে Foo
ঘোষণা করাঅতিরিক্তভাবে, মডিউল প্যাটার্নটি কোনও কনস্ট্রাক্টর সূচনা করতে ব্যবহার করা যেতে পারে, যা পরে একাধিকবার ইনস্ট্যান্ট করা যেতে পারে। যদিও মডিউল প্যাটার্নটি অনেক কাজের উপযুক্ত সরঞ্জাম, এটি কোনও সিঙ্গেলনের সমতুল্য নয়।
var Foo = function () {
"use strict";
if (Foo._instance) {
//this allows the constructor to be called multiple times
//and refer to the same instance. Another option is to
//throw an error.
return Foo._instance;
}
Foo._instance = this;
//Foo initialization code
};
Foo.getInstance = function () {
"use strict";
return Foo._instance || new Foo();
}
মডিউল প্যাটার্ন ব্যবহার করে লম্বা ফর্ম
var Foo = (function () {
"use strict";
var instance; //prevent modification of "instance" variable
function Singleton() {
if (instance) {
return instance;
}
instance = this;
//Singleton initialization code
}
//instance accessor
Singleton.getInstance = function () {
return instance || new Singleton();
}
return Singleton;
}());
আমি যে সিঙ্গলটন প্যাটার্নটি দিয়েছি তার উভয় সংস্করণে, নির্মাণকারী নিজেই অ্যাকসেসর হিসাবে ব্যবহার করতে পারেন:
var a,
b;
a = new Foo(); //constructor initialization happens here
b = new Foo();
console.log(a === b); //true
আপনি যদি কনস্ট্রাক্টরকে এভাবে ব্যবহার করতে স্বাচ্ছন্দ্য বোধ না করেন তবে আপনি if (instance)
বিবৃতিতে একটি ত্রুটি ফেলতে পারেন এবং দীর্ঘ ফর্মটি ব্যবহার করতে আটকে থাকতে পারেন:
var a,
b;
a = Foo.getInstance(); //constructor initialization happens here
b = Foo.getInstance();
console.log(a === b); //true
আমার আরও উল্লেখ করতে হবে যে সিঙ্গেলটন প্যাটার্নটি অন্তর্ভুক্ত কনস্ট্রাক্টর ফাংশন প্যাটার্নের সাথে ভাল ফিট করে:
function Foo() {
if (Foo._instance) {
return Foo._instance;
}
//if the function wasn't called as a constructor,
//call it as a constructor and return the result
if (!(this instanceof Foo)) {
return new Foo();
}
Foo._instance = this;
}
var f = new Foo(); //calls Foo as a constructor
-or-
var f = Foo(); //also calls Foo as a constructor
var singleton = {}
এই সংজ্ঞা ফিট করে না।
var singleton = {}
আপনি কীভাবে জাভাস্ক্রিপ্টে সিঙ্গলটন প্রয়োগ করেন ।
ইন es6
:
class Singleton {
constructor () {
if (!Singleton.instance) {
Singleton.instance = this
}
// Initialize object
return Singleton.instance
}
// Properties & Methods
}
const instance = new Singleton()
Object.freeze(instance)
export default instance
instance
ক্ষেত্রটি রাখে তা হিমশীতল হয়ে উঠবে । যেহেতু এটি বর্তমানে ( instance
সেট করা আছে this
) এই শ্রেণীর অন্যান্য ক্ষেত্রগুলিও থাকতে পারে এবং হিমাঙ্কটি ইমো তৈরি করে না।
নিম্নলিখিত নোড ভি 6 এ কাজ করে
class Foo {
constructor(msg) {
if (Foo.singleton) {
return Foo.singleton;
}
this.msg = msg;
Foo.singleton = this;
return Foo.singleton;
}
}
আমরা পরীক্ষা:
const f = new Foo('blah');
const d = new Foo('nope');
console.log(f); // => Foo { msg: 'blah' }
console.log(d); // => Foo { msg: 'blah' }
ES6 এ এটি করার সঠিক উপায় হ'ল:
class MyClass {
constructor() {
if (MyClass._instance) {
throw new Error("Singleton classes can't be instantiated more than once.")
}
MyClass._instance = this;
// ... your rest of the constructor code goes after this
}
}
var instanceOne = new MyClass() // Executes succesfully
var instanceTwo = new MyClass() // Throws error
অথবা, যদি আপনি না চান যে কোনও ত্রুটি দ্বিতীয় দৃষ্টান্ত তৈরির সময় নিক্ষেপ করা হয় তবে আপনি ঠিক শেষ উদাহরণটি ফিরে আসতে পারেন:
class MyClass {
constructor() {
if (MyClass._instance) {
return MyClass._instance
}
MyClass._instance = this;
// ... your rest of the constructor code goes after this
}
}
var instanceOne = new MyClass()
var instanceTwo = new MyClass()
console.log(instanceOne === instanceTwo) // logs "true"
instance
এবং _instance
। এটি প্রোগ্রামিং ভাষাগুলিতে কেবল একটি নামকরণের কনভেনশন যা আমরা আন্ডারস্কোর দিয়ে প্রাইভেট প্রাইভেট ভেরিয়েবলের নাম রাখি । আপনার কোডটি কাজ না করার কারণ আমি সন্দেহ করি যে আপনি এর this.instance
পরিবর্তে ব্যবহার করছেনMyClass.instance
একটি বিড়ালকে ত্বকে নেওয়ার একাধিক উপায় রয়েছে :) আপনার স্বাদ বা নির্দিষ্ট প্রয়োজনের উপর নির্ভর করে আপনি প্রস্তাবিত যে কোনও সমাধান প্রয়োগ করতে পারেন। আমি ব্যক্তিগতভাবে যখনই সম্ভব সিএমএসের প্রথম সমাধানের জন্য যাই (যখন আপনার গোপনীয়তার প্রয়োজন নেই)। যেহেতু প্রশ্নটি সবচেয়ে সহজ এবং পরিষ্কার সম্পর্কে ছিল, তবে এটিই বিজয়ী। অথবা এমনকি:
var myInstance = {}; // done!
এটি (আমার ব্লগের উদ্ধৃতি) ...
var SingletonClass = new function() {
this.myFunction() {
//do stuff
}
this.instance = 1;
}
এটি কোনও তাত্পর্যপূর্ণ নয় (আমার ব্লগের উদাহরণটিও হয় না) কারণ এটির জন্য কোনও প্রাইভেট ওয়ারের প্রয়োজন নেই, সুতরাং এটি প্রায় একই রকম:
var SingletonClass = {
myFunction: function () {
//do stuff
},
instance: 1
}
this.f(){}
আমি আমার উত্তর অবচয়, আমার অন্য একটি দেখুন ।
সাধারণত মডিউল প্যাটার্ন (সিএমএসের উত্তর দেখুন) যা সিঙ্গলটন প্যাটার্নটি যথেষ্ট ভাল নয়। তবে সিঙ্গলটনের অন্যতম বৈশিষ্ট্য হ'ল অবজেক্টের প্রয়োজন না হওয়া পর্যন্ত এর সূচনাটি বিলম্বিত হয়। মডিউল প্যাটার্নটিতে এই বৈশিষ্ট্যটি নেই।
আমার প্রস্তাব (কফি স্ক্রিপ্ট):
window.singleton = (initializer) ->
instance = undefined
() ->
return instance unless instance is undefined
instance = initializer()
যা জাভাস্ক্রিপ্ট এ এটি সংকলিত:
window.singleton = function(initializer) {
var instance;
instance = void 0;
return function() {
if (instance !== void 0) {
return instance;
}
return instance = initializer();
};
};
তারপরে আমি নিম্নলিখিতগুলি করতে পারি:
window.iAmSingleton = singleton(function() {
/* This function should create and initialize singleton. */
alert("creating");
return {property1: 'value1', property2: 'value2'};
});
alert(window.iAmSingleton().property2); // "creating" will pop up; then "value2" will pop up
alert(window.iAmSingleton().property2); // "value2" will pop up but "creating" will not
window.iAmSingleton().property2 = 'new value';
alert(window.iAmSingleton().property2); // "new value" will pop up
জাভাস্ক্রিপ্টের অ-অবরুদ্ধকরণের প্রকৃতির কারণে, জাভাস্ক্রিপ্টে সিঙ্গলেটগুলি সত্যই ব্যবহারে খারাপ। গ্লোবাল ভেরিয়েবলগুলি এই সমস্ত কলব্যাকগুলি ছাড়াই পুরো অ্যাপ্লিকেশনটির মাধ্যমে আপনাকে একটি উদাহরণ দেবে, মডিউল প্যাটার্নটি ইন্টারফেসের পিছনে আস্তে আস্তে আড়াল করে। @ সিএমএস উত্তর দেখুন।
তবে, যেহেতু আপনি একটি সিঙ্গলটন চেয়েছিলেন ...
var singleton = function(initializer) {
var state = 'initial';
var instance;
var queue = [];
var instanceReady = function(createdInstance) {
state = 'ready';
instance = createdInstance;
while (callback = queue.shift()) {
callback(instance);
}
};
return function(callback) {
if (state === 'initial') {
state = 'waiting';
queue.push(callback);
initializer(instanceReady);
} else if (state === 'waiting') {
queue.push(callback);
} else {
callback(instance);
}
};
};
ব্যবহার:
var singletonInitializer = function(instanceReady) {
var preparedObject = {property: 'value'};
// calling instanceReady notifies singleton that instance is ready to use
instanceReady(preparedObject);
}
var s = singleton(singletonInitializer);
// get instance and use it
s(function(instance) {
instance.doSomething();
});
সিলেটলেটগুলি পুরো অ্যাপ্লিকেশনটির মাধ্যমে আপনাকে কেবলমাত্র একটি উদাহরণ দেয়: প্রথমটি ব্যবহার না করা পর্যন্ত তাদের সূচনা বিলম্বিত। যার আদ্যক্ষর ব্যয়বহুল এমন জিনিসগুলির সাথে আপনি যখন ডিল করেন তখন এটি সত্যিই বড় জিনিস। ব্যয়বহুলের অর্থ সাধারণত I / O এবং জাভাস্ক্রিপ্টে I / O সর্বদা কলব্যাক হয়।
যে উত্তরগুলি আপনাকে ইন্টারফেসের মতো উত্তর দেয় তাতে বিশ্বাস করবেন না instance = singleton.getInstance()
, তারা সমস্তই পয়েন্টটি মিস করে।
উদাহরণস্বরূপ প্রস্তুত হওয়ার পরে যদি তারা কলব্যাক চালানোর জন্য না নেয়, তবে আরম্ভকারী আই / ও করলে তারা কাজ করবে না।
হ্যাঁ, কলব্যাকগুলি সর্বদা ফাংশন কলের চেয়ে খারাপ লাগে যা অবিলম্বে বস্তুর উদাহরণ দেয়। তবে আবার: আপনি যখন I / O করেন, কলব্যাকগুলি বাধ্যতামূলক। আপনি যদি কোনও আই / ও না করতে চান তবে প্রোগ্রামের শুরুতে ইনস্ট্যান্টেশনটি এটি যথেষ্ট সস্তা।
var simpleInitializer = function(instanceReady) {
console.log("Initializer started");
instanceReady({property: "initial value"});
}
var simple = singleton(simpleInitializer);
console.log("Tests started. Singleton instance should not be initalized yet.");
simple(function(inst) {
console.log("Access 1");
console.log("Current property value: " + inst.property);
console.log("Let's reassign this property");
inst.property = "new value";
});
simple(function(inst) {
console.log("Access 2");
console.log("Current property value: " + inst.property);
});
এই উদাহরণে setTimeout
কিছু ব্যয়বহুল আই / ও অপারেশন জালিয়াতি করে। এটি জাভাস্ক্রিপ্টে সিঙ্গেলটনের কেন সত্যিই কলব্যাকের প্রয়োজন তা বোঝায়।
var heavyInitializer = function(instanceReady) {
console.log("Initializer started");
var onTimeout = function() {
console.log("Initializer did his heavy work");
instanceReady({property: "initial value"});
};
setTimeout(onTimeout, 500);
};
var heavy = singleton(heavyInitializer);
console.log("In this example we will be trying");
console.log("to access singleton twice before it finishes initialization.");
heavy(function(inst) {
console.log("Access 1");
console.log("Current property value: " + inst.property);
console.log("Let's reassign this property");
inst.property = "new value";
});
heavy(function(inst) {
console.log("Access 2. You can see callbacks order is preserved.");
console.log("Current property value: " + inst.property);
});
console.log("We made it to the end of the file. Instance is not ready yet.");
আমি জাভাস্ক্রিপ্ট প্যাটার্নস কোডিং এবং ডিজাইন প্যাটার্নস সহ আরও ভাল অ্যাপ্লিকেশনগুলি স্টোয়ান স্টেফানভের বইয়ের দ্বারা এই উদাহরণটি পেয়েছি যদি আপনি সিঙ্গলটোন অবজেক্টের মতো কিছু সাধারণ বাস্তবায়ন ক্লাসের প্রয়োজন হয় তবে আপনি নীচের হিসাবে তাত্ক্ষণিক ফাংশনটি ব্যবহার করতে পারেন:
var ClassName;
(function() {
var instance;
ClassName = function ClassName() {
//If private instance variable already initialized return reference
if(instance) {
return instance;
}
//If instance does not created save pointer of original reference
//to private instance variable.
instance = this;
//All constructor initialization will be here
// i.e.:
this.someProperty = 0;
this.someMethod = function() {
//Some action here
};
};
}());
এবং আপনি পরীক্ষার কেস অনুসরণ করে এই উদাহরণটি পরীক্ষা করতে পারেন:
//Extending defined class like Singltone object using new prototype property
ClassName.prototype.nothing = true;
var obj_1 = new ClassName();
//Extending defined class like Singltone object using new prototype property
ClassName.prototype.everything = true;
var obj_2 = new ClassName();
//Testing does this two object pointing to same instance
console.log(obj_1 === obj_2); //Result is true, it points to same instance object
//All prototype properites work
//no matter when they were defined
console.log(obj_1.nothing && obj_1.everything
&& obj_2.nothing && obj_2.everything); //Result true
//Values of properties which is defined inside of constructor
console.log(obj_1.someProperty);// output 0
console.log(obj_2.someProperty);// output 0
//Changing property value
obj_1.someProperty = 1;
console.log(obj_1.someProperty);// output 1
console.log(obj_2.someProperty);// output 1
console.log(obj_1.constructor === ClassName); //Output true
প্রোটোটাইপ এক্সটেনশন ব্যবহার করার সময় ব্যক্তিগত স্ট্যাটিক প্রয়োগ ব্যর্থ হয় (এটি স্থির করা যেতে পারে তবে এটি সহজ হবে না) এবং জনসাধারণের স্ট্যাটিক বাস্তবায়ন কম পরামর্শ দেওয়ার কারণে জনগণের সামনে উন্মুক্ত হলে এই পরীক্ষার সমস্ত পরীক্ষায় পাস হয়।
আমি মনে করি আমি জাভাস্ক্রিপ্টে প্রোগ্রামের সবচেয়ে পরিষ্কার উপায় খুঁজে পেয়েছি, তবে আপনার কিছু কল্পনা প্রয়োজন। "জাভাস্ক্রিপ্ট ভাল অংশগুলি" বইয়ের একটি কাজের কৌশল থেকে এই ধারণাটি পেয়েছি।
নতুন কীওয়ার্ডটি ব্যবহার না করে আপনি এই জাতীয় শ্রেণি তৈরি করতে পারেন:
function Class()
{
var obj = {}; // Could also be used for inheritence if you don't start with an empty object.
var privateVar;
obj.publicVar;
obj.publicMethod= publicMethod;
function publicMethod(){}
function privateMethod(){}
return obj;
}
আপনি উপরের বস্তুটি তা বলে তাত্ক্ষণিক করে তুলতে পারেন:
var objInst = Class(); // !!! NO NEW KEYWORD
এখন এই কাজের পদ্ধতিটি মনে রেখে আপনি এই জাতীয় একটি সিঙ্গলটন তৈরি করতে পারেন:
ClassSingleton = function()
{
var instance= null;
function Class() // This is the class like the above one
{
var obj = {};
return obj;
}
function getInstance()
{
if( !instance )
instance = Class(); // Again no new keyword;
return instance;
}
return { getInstance : getInstance };
}();
এখন আপনি কল করে আপনার উদাহরণটি পেতে পারেন
var obj = ClassSingleton.getInstance();
সম্পূর্ণ "শ্রেণি" এমনকি অ্যাক্সেসযোগ্য না হওয়ায় এটি আমার নিকটতম উপায় way
@ সিএমএস এবং @zzzzBov উভয়ই দুর্দান্ত উত্তর দিয়েছেন, তবে কেবল পিএইচপি / জেন্ডার ফ্রেমওয়ার্ক থেকে ভারী নোড.জেএস এর বিকাশের উপর ভিত্তি করে আমার নিজস্ব ব্যাখ্যা যুক্ত করতে যেখানে সিঙ্গলটনের প্যাটার্নগুলি সাধারণ ছিল।
নিম্নলিখিত, মন্তব্য-নথিভুক্ত কোড নিম্নলিখিত প্রয়োজনীয়তার উপর ভিত্তি করে:
আমার কোডটি @ zzzzBov এর মতই অনুরূপ বাদে আমি কন্সট্রাক্টরের একটি প্রোটোটাইপ চেইন এবং আরও মন্তব্য দিয়েছি যা পিএইচপি বা অনুরূপ ভাষা থেকে আগতদের জাভাস্ক্রিপ্টের প্রোটোটাইপিক প্রকৃতিতে traditionalতিহ্যবাহী ওওপি অনুবাদ করতে সহায়তা করবে except এটি "সাদামাটা" নাও হতে পারে তবে আমি বিশ্বাস করি এটি সবচেয়ে উপযুক্ত proper
// declare 'Singleton' as the returned value of a self-executing anonymous function
var Singleton = (function () {
"use strict";
// 'instance' and 'constructor' should not be availble in a "public" scope
// here they are "private", thus available only within
// the scope of the self-executing anonymous function
var _instance=null;
var _constructor = function (name) {
this.name = name || 'default';
}
// prototypes will be "public" methods available from the instance
_constructor.prototype.getName = function () {
return this.name;
}
// using the module pattern, return a static object
// which essentially is a list of "public static" methods
return {
// because getInstance is defined within the same scope
// it can access the "private" 'instance' and 'constructor' vars
getInstance:function (name) {
if (!_instance) {
console.log('creating'); // this should only happen once
_instance = new _constructor(name);
}
console.log('returning');
return _instance;
}
}
})(); // self execute
// ensure 'instance' and 'constructor' are unavailable
// outside the scope in which they were defined
// thus making them "private" and not "public"
console.log(typeof _instance); // undefined
console.log(typeof _constructor); // undefined
// assign instance to two different variables
var a = Singleton.getInstance('first');
var b = Singleton.getInstance('second'); // passing a name here does nothing because the single instance was already instantiated
// ensure 'a' and 'b' are truly equal
console.log(a === b); // true
console.log(a.getName()); // "first"
console.log(b.getName()); // also returns "first" because it's the same instance as 'a'
নোট করুন যে প্রযুক্তিগতভাবে, স্ব-সম্পাদনকারী বেনাম ফাংশনটি নিজেই সিঙ্গেলটন হিসাবে @ সিএমএসের দেওয়া কোডটিতে দুর্দান্তভাবে প্রদর্শিত হয়েছে। এখানে কেবল ধরাটিই হল যখন কনস্ট্রাক্টর নিজেই বেনামে থাকে তখন কনস্ট্রাক্টরের প্রোটোটাইপ চেইনটি পরিবর্তন করা সম্ভব হয় না।
মনে রাখবেন যে জাভাস্ক্রিপ্টের কাছে, "পাবলিক" এবং "প্রাইভেট" ধারণাগুলি পিএইচপি বা জাভাতে প্রয়োগ হয় না। তবে জাভাস্ক্রিপ্টের কার্যক্ষম সুযোগের প্রাপ্যতার বিধিগুলিকে কাজে লাগিয়ে আমরা একই প্রভাব অর্জন করেছি।
var a = Singleton.getInstance('foo'); var b = new a.constructor('bar');
কেন কেউ এটিকে সামনে আনেনি তা নিশ্চিত নয় তবে আপনি কেবল এটি করতে পারেন:
var singleton = new (function() {
var bar = 123
this.foo = function() {
// whatever
}
})()
স্পষ্ট উত্তরটি অ্যাডি ওসমানীর লিখন জাভাস্ক্রিপ্ট ডিজাইন প্যাটার্নস থেকে পাওয়া উচিত।
var mySingleton = (function () {
// Instance stores a reference to the Singleton
var instance;
function init() {
// Singleton
// Private methods and variables
function privateMethod(){
console.log( "I am private" );
}
var privateVariable = "Im also private";
var privateRandomNumber = Math.random();
return {
// Public methods and variables
publicMethod: function () {
console.log( "The public can see me!" );
},
publicProperty: "I am also public",
getRandomNumber: function() {
return privateRandomNumber;
}
};
};
return {
// Get the Singleton instance if one exists
// or create one if it doesn't
getInstance: function () {
if ( !instance ) {
instance = init();
}
return instance;
}
};
})();
আমি বিশ্বাস করি এটি ES7 প্রয়োজন যদিও এটি সবচেয়ে সহজ / পরিষ্কার এবং স্বজ্ঞাত উপায়:
export default class Singleton { static instance; constructor(){ if(instance){ return instance; } this.state = "duke"; this.instance = this; } }
উত্স কোডটি হ'ল: অ্যাডাম-বিবিএন ডটকম
new Singleton()
আমি কি আমার 5 কয়েন রাখতে পারি? আমার একটি কনস্ট্রাক্টর ফাংশন আছে, প্রাক্তন।
var A = function(arg1){
this.arg1 = arg1
};
আমাকে যা করতে হবে তা হ'ল এই সিএফ দ্বারা তৈরি প্রতিটি বস্তু একই হবে।
var X = function(){
var instance = {};
return function(){ return instance; }
}();
পরীক্ষা
var x1 = new X();
var x2 = new X();
console.log(x1 === x2)
কারণ ব্যবহার আমি সবচেয়ে সহজ পদ্ধিতি হল একক প্যাটার্ন হতে নিম্নলিখিত খুঁজে পেয়েছেন নতুন অপারেটর তোলে এই অবিলম্বে ফাংশন মধ্যে পাওয়া যায়, একটি বস্তুর আক্ষরিক আসতে করতে হবে দূর:
var singleton = new (function () {
var private = "A private value";
this.printSomething = function() {
console.log(private);
}
})();
singleton.printSomething();
জাভাস্ক্রিপ্টে সিঙ্গেলটন প্যাটার্নটি ব্যাখ্যা করার সহজ উদাহরণ এখানে।
var Singleton=(function(){
var instance;
var init=function(){
return {
display:function(){
alert("This is a Singleton patern demo");
}
};
};
return {
getInstance:function(){
if(!instance){
alert("Singleton check");
instance=init();
}
return instance;
}
};
})();
// In this call first display alert("Singleton check")
// and then alert("This is a Singleton patern demo");
// It means one object is created
var inst=Singleton.getInstance();
inst.display();
// In this call only display alert("This is a Singleton patern demo")
// it means second time new object is not created,
// it uses the already created object
var inst1=Singleton.getInstance();
inst1.display();
আমার সাথে বেশ কয়েকটি সিলেটলেট প্রয়োজন:
এবং তাই এটিই আমি নিয়ে এসেছি:
createSingleton ('a', 'add', [1, 2]);
console.log(a);
function createSingleton (name, construct, args) {
window[name] = {};
window[construct].apply(window[name], args);
window[construct] = null;
}
function add (a, b) {
this.a = a;
this.b = b;
this.sum = a + b;
}
কাজ করার জন্য আরোগুলি অবশ্যই অ্যারে হওয়া উচিত তাই আপনার যদি খালি ভেরিয়েবল থাকে তবে কেবল প্রবেশ করুন []
আমি ফাংশনে উইন্ডো অবজেক্টটি ব্যবহার করেছি তবে আমি আমার নিজস্ব সুযোগ তৈরি করতে কোনও পরামিতি পেরিয়ে যেতে পারতাম
নাম এবং কনস্ট্রাক্ট প্যারামিটারগুলি কেবল উইন্ডো [] এর কাজ করার জন্য স্ট্রিং তবে কিছু সাধারণ টাইপ-চেকিংয়ের সাথে উইন্ডো.নাম এবং উইন্ডো কনস্ট্রাক্টও সম্ভব।
এই উপায়টি সম্পর্কে কীভাবে, ক্লাসটি আবার নতুন করে বীমাকরণ করা যায় না।
এটির মাধ্যমে আপনি ব্যবহার করতে পারেন instanceof
অপ, এছাড়াও, আপনি প্রোটোটাইপ শৃঙ্খল ব্যবহার করতে পারেন বর্গ উত্তরাধিকারী, এটি একটি নিয়মিত ক্লাসে, কিন্তু না করতে পারেন নতুন এটা Yuu উদাহরণস্বরূপ শুধু ব্যবহার পেতে চাইলে দয়াgetInstance
function CA()
{
if(CA.instance)
{
throw new Error('can not new this class');
}else{
CA.instance = this;
}
}
/**
* @protected
* @static
* @type {CA}
*/
CA.instance = null;
/** @static */
CA.getInstance = function()
{
return CA.instance;
}
CA.prototype =
/** @lends CA#*/
{
func: function(){console.log('the func');}
}
// initilize the instance
new CA();
// test here
var c = CA.getInstance()
c.func();
console.assert(c instanceof CA)
// this will failed
var b = new CA();
আপনি যদি সদস্যটিকে প্রকাশ করতে না চান তবে instance
এটি বন্ধ করে দিন।
সিঙ্গেলটন প্যাটার্নটি বাস্তবায়নের জন্য আমার পদচারণা থেকে স্নিপেটটি নীচে দেওয়া হয়েছে। একটি সাক্ষাত্কার প্রক্রিয়া চলাকালীন আমার কাছে এটি ঘটেছিল এবং আমি অনুভব করেছি যে এটি আমার কোথাও ক্যাপচার করা উচিত।
/*************************************************
* SINGLETON PATTERN IMPLEMENTATION *
*************************************************/
//since there are no classes in javascript, every object is technically a singleton
//if you don't inherit from it or copy from it.
var single = {};
//Singleton Implementations
//Declaring as a Global Object...you are being judged!
var Logger = function() {
//global_log is/will be defined in GLOBAL scope here
if(typeof global_log === 'undefined'){
global_log = this;
}
return global_log;
};
//the below 'fix' solves the GLOABL variable problem but
//the log_instance is publicly available and thus can be
//tampered with.
function Logger() {
if(typeof Logger.log_instance === 'undefined'){
Logger.log_instance = this;
}
return Logger.log_instance;
};
//the correct way to do it to give it a closure!
function logFactory() {
var log_instance; //private instance
var _initLog = function() { //private init method
log_instance = 'initialized';
console.log("logger initialized!")
}
return {
getLog : function(){ //the 'privileged' method
if(typeof log_instance === 'undefined'){
_initLog();
}
return log_instance;
}
};
}
/***** TEST CODE ************************************************
//using the Logger singleton
var logger = logFactory();//did i just gave LogFactory a closure?
//create an instance of the logger
var a = logger.getLog();
//do some work
//get another instance of the logger
var b = logger.getLog();
//check if the two logger instances are same?
console.log(a === b); //true
*******************************************************************/
একই আমার টুকরো পৃষ্ঠায় পাওয়া যাবে
function Unicode()
{
var i = 0, unicode = {}, zero_padding = "0000", max = 9999;
//Loop through code points
while (i < max) {
//Convert decimal to hex value, find the character, then pad zeroes to the codepoint
unicode[String.fromCharCode(parseInt(i, 16))] = ("u" + zero_padding + i).substr(-4);
i = i + 1;
}
//Replace this function with the resulting lookup table
Unicode = unicode;
}
//Usage
Unicode();
//Lookup
Unicode["%"]; //returns 0025
আপনি টাইপস্ক্রিপ্টের জন্য নীচে এই উদাহরণের মতো সজ্জিতদের সাথে এটি করতে পারেন:
class YourClass {
@Singleton static singleton() {}
}
function Singleton(target, name, descriptor) {
var instance;
descriptor.value = () => {
if(!instance) instance = new target;
return instance;
};
}
তারপরে আপনি আপনার সিঙ্গেলটনটি এভাবে ব্যবহার করুন:
var myInstance = YourClass.singleton();
এই লেখার হিসাবে, সজ্জাকরণগুলি জাভাস্ক্রিপ্ট ইঞ্জিনগুলিতে সহজেই পাওয়া যায় না। আপনার জাভাস্ক্রিপ্ট রানটাইমটিতে সজ্জাকারীরা আসলে সক্ষম হয়েছে বা ব্যাবেল এবং টাইপস্ক্রিপ্টের মতো সংকলক ব্যবহার করতে পারে তা নিশ্চিত করতে হবে।
এছাড়াও নোট করুন যে সিঙ্গলটন উদাহরণটি "অলস" তৈরি করা হয়েছে, অর্থাত্ আপনি যখন এটি প্রথমবার ব্যবহার করবেন তখনই এটি তৈরি করা হবে।
মডিউল প্যাটার্ন: "আরও পাঠযোগ্য শৈলীতে"। আপনি সহজেই দেখতে পারবেন কোন পদ্ধতিগুলি সর্বজনীন এবং কোনটি ব্যক্তিগত are
var module = (function(_name){
/*Local Methods & Values*/
var _local = {
name : _name,
flags : {
init : false
}
}
function init(){
_local.flags.init = true;
}
function imaprivatemethod(){
alert("hi im a private method");
}
/*Public Methods & variables*/
var $r = {}; //this object will hold all public methods.
$r.methdo1 = function(){
console.log("method1 call it");
}
$r.method2 = function(){
imaprivatemethod(); //calling private method
}
$r.init = function(){
inti(); //making init public in case you want to init manually and not automatically
}
init(); //automatically calling init method
return $r; //returning all publics methods
})("module");
এখন আপনি যেমন পাবলিক পদ্ধতি ব্যবহার করতে পারেন
module.method2 (); // -> আমি একটি পাবলিক মেথড অ্যালার্টের মাধ্যমে একটি ব্যক্তিগত পদ্ধতি কল করছি ("হাই আইএম একটি ব্যক্তিগত পদ্ধতি")
একক:
নিশ্চিত করুন যে কোনও শ্রেণীর কাছে কেবলমাত্র একটি উদাহরণ রয়েছে এবং এটিতে একটি বিশ্বব্যাপী অ্যাক্সেস সরবরাহ করে।
সিঙ্গলটন প্যাটার্নটি নির্দিষ্ট কোনও বস্তুর উদাহরণগুলির সংখ্যা কেবল একটিতে সীমাবদ্ধ করে। এই একক উদাহরণটিকে সিঙ্গেলটন বলা হয়।
সিঙ্গলটন অবজেক্টটি তাত্ক্ষণিক বেনাম ফাংশন হিসাবে প্রয়োগ করা হয়েছে। ফাংশনটি তত্ক্ষণাত বন্ধনীগুলিতে মুড়ে তার পরে দুটি অতিরিক্ত বন্ধনী দ্বারা কার্য সম্পাদন করে। এটি নামহীন বলে কারণ এটির কোনও নাম নেই।
নমুনা প্রোগ্রাম,
var Singleton = (function () {
var instance;
function createInstance() {
var object = new Object("I am the instance");
return object;
}
return {
getInstance: function () {
if (!instance) {
instance = createInstance();
}
return instance;
}
};
})();
function run() {
var instance1 = Singleton.getInstance();
var instance2 = Singleton.getInstance();
alert("Same instance? " + (instance1 === instance2));
}
run()
আমার পক্ষে সর্বাধিকতম / ক্লিনস্ট অর্থ হ'ল আলোচনার জাভা সংস্করণে যেমন আলোচনা করা হয়েছে তেমন কোনও ঘণ্টা এবং হুইসেল বোঝাও নয়:
জাভাতে সিঙ্গলটন প্যাটার্ন কার্যকর করার কার্যকর উপায় কী?
আমার দৃষ্টিকোণ থেকে যে উত্তরটি সবচেয়ে সহজ / সবচেয়ে ভাল ফিট হবে তা হ'ল:
https://stackoverflow.com/a/70824/1497139
এবং এটি আংশিকভাবে জাভাস্ক্রিপ্ট অনুবাদ করা যেতে পারে। জাভাস্ক্রিপ্টের কিছু পার্থক্য হ'ল:
তবে সর্বশেষতম ইসিএমএ সিনট্যাক্স দেওয়া থাকলে এর সাথে ঘনিষ্ঠ হওয়া সম্ভব:
জাভাস্ক্রিপ্ট শ্রেণীর উদাহরণ হিসাবে একক প্যাটার্ন
class Singleton {
constructor(field1,field2) {
this.field1=field1;
this.field2=field2;
Singleton.instance=this;
}
static getInstance() {
if (!Singleton.instance) {
Singleton.instance=new Singleton('DefaultField1','DefaultField2');
}
return Singleton.instance;
}
}
ব্যবহারের উদাহরণ
console.log(Singleton.getInstance().field1);
console.log(Singleton.getInstance().field2);
উদাহরণ ফলাফল
DefaultField1
DefaultField2
function Once() {
return this.constructor.instance || (this.constructor.instance = this);
}
function Application(name) {
let app = Once.call(this);
app.name = name;
return app;
}
আপনি যদি ক্লাসে থাকেন:
class Once {
constructor() {
return this.constructor.instance || (this.constructor.instance = this);
}
}
class Application extends Once {
constructor(name) {
super();
this.name = name;
}
}
টেস্ট:
console.log(new Once() === new Once());
let app1 = new Application('Foobar');
let app2 = new Application('Barfoo');
console.log(app1 === app2);
console.log(app1.name); // Barfoo
আপনি যদি ক্লাস ব্যবহার করতে চান:
class Singleton {
constructor(name, age) {
this.name = name;
this.age = age;
if(this.constructor.instance)
return this.constructor.instance;
this.constructor.instance = this;
}
}
let x = new Singleton('s',1);
let y = new Singleton('k',2);
উপরের জন্য আউটপুট হবে:
console.log(x.name,x.age,y.name,y.age) // s 1 s 1
ফাংশন ব্যবহার করে সিঙ্গেলটন লেখার আর একটি উপায়
function AnotherSingleton (name,age) {
this.name = name;
this.age = age;
if(this.constructor.instance)
return this.constructor.instance;
this.constructor.instance = this;
}
let a = new AnotherSingleton('s',1);
let b = new AnotherSingleton('k',2);
উপরের জন্য আউটপুট হবে:
console.log(a.name,a.age,b.name,b.age)// s 1 s 1