singleton - টাইপস্ক্রিপ্টে সিঙ্গলটনের সংজ্ঞা কীভাবে দেওয়া যায়




typescript (12)

আপনি এর জন্য ক্লাস এক্সপ্রেশন ব্যবহার করতে পারেন (আমার বিশ্বাস 1.6 হিসাবে)।

var x = new (class {
    /* ... lots of singleton logic ... */
    public someMethod() { ... }
})();

বা নামের সাথে যদি আপনার শ্রেণীর অভ্যন্তরীণভাবে এর ধরণের অ্যাক্সেসের প্রয়োজন হয়

var x = new (class Singleton {
    /* ... lots of singleton logic ... */
    public someMethod(): Singleton { ... }
})();

অন্য বিকল্পটি হ'ল কিছু স্থিতিশীল সদস্য ব্যবহার করে আপনার সিঙ্গলটনের অভ্যন্তরে একটি স্থানীয় শ্রেণি ব্যবহার করা

class Singleton {

    private static _instance;
    public static get instance() {

        class InternalSingleton {
            someMethod() { }

            //more singleton logic
        }

        if(!Singleton._instance) {
            Singleton._instance = new InternalSingleton();
        }

        return <InternalSingleton>Singleton._instance;
    }
}

var x = Singleton.instance;
x.someMethod();

টাইপস্ক্রিপ্টে কোনও শ্রেণীর জন্য সিঙ্গলটন প্যাটার্ন বাস্তবায়নের সর্বোত্তম এবং সবচেয়ে সুবিধাজনক উপায় কী? (অলস সূচনা সহ এবং ছাড়া উভয়)।


আপনি ফাংশন অবজেক্ট.ফ্রিজে () ব্যবহার করতে পারেন। এটি সহজ এবং সহজ:

class Singleton {

  instance: any = null;
  data: any = {} // store data in here

  constructor() {
    if (!this.instance) {
      this.instance = this;
    }
    return this.instance
  }
}

const singleton: Singleton = new Singleton();
Object.freeze(singleton);

export default singleton;

আমি মনে করি সম্ভবত জেনারিকগুলি ব্যাটার হতে হবে

class Singleton<T>{
    public static Instance<T>(c: {new(): T; }) : T{
        if (this._instance == null){
            this._instance = new c();
        }
        return this._instance;
    }

    private static _instance = null;
}

কিভাবে ব্যবহার করে

ধাপ 1

class MapManager extends Singleton<MapManager>{
     //do something
     public init():void{ //do }
}

ধাপ ২

    MapManager.Instance(MapManager).init();

আমি সবচেয়ে ভাল উপায় খুঁজে পেয়েছি:

class SingletonClass {

    private static _instance:SingletonClass = new SingletonClass();

    private _score:number = 0;

    constructor() {
        if(SingletonClass._instance){
            throw new Error("Error: Instantiation failed: Use SingletonClass.getInstance() instead of new.");
        }
        SingletonClass._instance = this;
    }

    public static getInstance():SingletonClass
    {
        return SingletonClass._instance;
    }

    public setScore(value:number):void
    {
        this._score = value;
    }

    public getScore():number
    {
        return this._score;
    }

    public addPoints(value:number):void
    {
        this._score += value;
    }

    public removePoints(value:number):void
    {
        this._score -= value;
    }

}

আপনি এটি কীভাবে ব্যবহার করবেন তা এখানে:

var scoreManager = SingletonClass.getInstance();
scoreManager.setScore(10);
scoreManager.addPoints(1);
scoreManager.removePoints(2);
console.log( scoreManager.getScore() );

codebelt.com/typescript/typescript-singleton-pattern


এটি সহজতম উপায়

class YourSingletoneClass {
  private static instance: YourSingletoneClass;

  private constructor(public ifYouHaveAnyParams: string) {

  }
  static getInstance() {
    if(!YourSingletoneClass.instance) {
      YourSingletoneClass.instance = new YourSingletoneClass('If you have any params');
    }
    return YourSingletoneClass.instance;
  }
}

এর জন্য আমার সমাধান:

export default class Modal {
    private static _instance : Modal = new Modal();

    constructor () {
        if (Modal._instance) 
            throw new Error("Use Modal.instance");
        Modal._instance = this;
    }

    static get instance () {
        return Modal._instance;
    }
}

টাইপসক্রিপ্টে, অবশ্যই অগত্যা new instance() অনুসরণ করতে হবে না new instance() সিঙ্গলটন পদ্ধতিটি। একটি আমদানিকৃত, কনস্ট্রাক্টর-কম স্ট্যাটিক ক্লাস পাশাপাশি সমানভাবে কাজ করতে পারে।

বিবেচনা:

export class YourSingleton {

   public static foo:bar;

   public static initialise(_initVars:any):void {
     YourSingleton.foo = _initvars.foo;
   }

   public static doThing():bar {
     return YourSingleton.foo
   }
}

আপনি ক্লাসটি আমদানি করতে পারেন এবং অন্য যে কোনও শ্রেণিতে YourSingleton.doThing() পড়ুন। তবে মনে রাখবেন, কারণ এটি একটি স্ট্যাটিক ক্লাস, এটির কোনও নির্মাণকারী নেই তাই আমি সাধারণত intialise() পদ্ধতিটি ব্যবহার করি যা একটি ক্লাস থেকে ডাকা হয় যা সিঙ্গলটন আমদানি করে:

import {YourSingleton} from 'singleton.ts';

YourSingleton.initialise(params);
let _result:bar = YourSingleton.doThing();

ভুলে যাবেন না যে একটি স্ট্যাটিক ক্লাসে, প্রতিটি পদ্ধতি এবং ভেরিয়েবলেরও স্থির হওয়া দরকার তাই এর পরিবর্তে আপনি পুরো শ্রেণীর নাম YourSingleton ব্যবহার করবেন।


টাইপস্ক্রিপ্টে একক ক্লাসগুলি সাধারণত একটি অ্যান্টি-প্যাটার্ন হয়। পরিবর্তে আপনি কেবল নেমস্পেস ব্যবহার করতে পারেন।

অকেজো একক প্যাটার্ন

class Singleton {
    /* ... lots of singleton logic ... */
    public someMethod() { ... }
}

// Using
var x = Singleton.getInstance();
x.someMethod();

নেমস্পেস সমতুল্য

export namespace Singleton {
    export function someMethod() { ... }
}
// Usage
import { SingletonInstance} from "path/to/Singleton";

SingletonInstance.someMethod();
var x = SingletonInstance; // If you need to alias it for some reason

টিএস ২.০, যেহেতু আমরা কনস্ট্রাক্টরগুলিতে ভিজিবিলিটি মডিফায়ারগুলি সংজ্ঞায়িত করার ক্ষমতা রাখি, তাই এখন আমরা টাইপসক্রিপ্টে সিঙ্গেলনগুলি করতে পারি যেমন আমরা অন্যান্য ভাষা থেকে ব্যবহার করি।

উদাহরণ দেওয়া:

class MyClass
{
    private static _instance: MyClass;

    private constructor()
    {
        //...
    }

    public static get Instance()
    {
        // Do you need arguments? Make it a regular static method instead.
        return this._instance || (this._instance = new this());
    }
}

const myClassInstance = MyClass.Instance;

@ ড্রেনাই আপনাকে এই প্রতিশ্রুতি দেওয়ার জন্য ধন্যবাদ যে আপনি কাঁচা সংকলিত জাভাস্ক্রিপ্ট ব্যবহার করে কোড লিখলে আপনার একাধিক তদন্তের বিরুদ্ধে সুরক্ষা থাকবে না, কারণ টিএস-এর সীমাবদ্ধতাগুলি অদৃশ্য হয়ে যায় এবং কনস্ট্রাক্টরটি লুকানো থাকবে না।


নিম্নলিখিত পদ্ধতিটি একটি সিঙ্গলটন শ্রেণি তৈরি করে যা প্রচলিত শ্রেণীর মতো বহুলভাবে ব্যবহৃত হতে পারে:

class Singleton {
    private static instance: Singleton;
    //Assign "new Singleton()" here to avoid lazy initialisation

    constructor() {
        if (Singleton.instance) {
            return Singleton.instance;
        }

        this. member = 0;
        Singleton.instance = this;
    }

    member: number;
}

প্রতিটি new Singleton() অপারেশন একই উদাহরণ ফিরে আসবে। এটি তবে ব্যবহারকারীর দ্বারা অপ্রত্যাশিত হতে পারে।

নিম্নলিখিত উদাহরণটি ব্যবহারকারীর কাছে আরও স্বচ্ছ তবে পৃথক ব্যবহারের প্রয়োজন:

class Singleton {
    private static instance: Singleton;
    //Assign "new Singleton()" here to avoid lazy initialisation

    constructor() {
        if (Singleton.instance) {
            throw new Error("Error - use Singleton.getInstance()");
        }
        this.member = 0;
    }

    static getInstance(): Singleton {
        Singleton.instance = Singleton.instance || new Singleton();
        return Singleton.instance;
    }

    member: number;
}

ব্যবহার: var obj = Singleton.getInstance();


IFFE ব্যবহার করে আরও প্রচলিত জাভাস্ক্রিপ্ট পদ্ধতির সাথে এটি করার আরও একটি উপায় এখানে রয়েছে:

module App.Counter {
    export var Instance = (() => {
        var i = 0;
        return {
            increment: (): void => {
                i++;
            },
            getCount: (): number => {
                return i;
            }
        }
    })();
}

module App {
    export function countStuff() {
        App.Counter.Instance.increment();
        App.Counter.Instance.increment();
        alert(App.Counter.Instance.getCount());
    }
}

App.countStuff();

একটি demo দেখুন


class MySingleton {
constructor(message) {
    alert('hello' + message);
}
private static instance: MySingleton;
private static instance2: MySingleton;

public static getSessionStorageInstance() {
    if (!MySingleton.instance) {
        MySingleton.instance = new MySingleton("world");
    }
    return MySingleton.instance;
}

public static getSessionStorageInstance2() {
    if (!MySingleton.instance2) {
        MySingleton.instance2 = new MySingleton("youu");
    }
    return MySingleton.instance2;
 }
}

 const a: MySingleton = MySingleton.getSessionStorageInstance();
 const b: MySingleton = MySingleton.getSessionStorageInstance2();

 alert(a === b)