Ist es möglich, einem Enum-Typ in TypeScript Funktionen hinzuzufügen?

zum Beispiel:

enum Mode {
    landscape,
    portrait,

    // the dream...
    toString() { console.log(this); } 
}

Oder:

class ModeExtension {
    public toString = () => console.log(this);
}

enum Mode extends ModeExtension {
    landscape,
    portrait,
}

Natürlich toString()würde die Funktion so etwas wie ein enthalten. switchAber ein Anwendungsfall würde folgendermaßen verlaufen:

class Device {
    constructor(public mode:Mode) {
        console.log(this.mode.toString());
    }
}

Ich verstehe, warum enumes eine seltsame Sache sein kann, ein zu erweitern, und frage mich nur, ob es möglich ist.

Sie können entweder eine Klasse haben, die von der Aufzählung getrennt ist, und sie verwenden, um die gewünschten Dinge abzurufen, oder Sie können einen Namespace in die Aufzählung einbinden und alles an einer Stelle abrufen, die an derselben Stelle aussieht.

Modus-Dienstprogrammklasse

Dies ist also nicht genau das, wonach Sie suchen, aber dies ermöglicht es Ihnen, das Verhalten von "Mode to String" mithilfe einer statischen Methode zu kapseln.

class ModeUtil {
    public static toString(mode: Mode) {
        return Mode[mode];
    }
}

Sie können es so verwenden:

const mode = Mode.portrait;
const x = ModeUtil.toString(mode);
console.log(x);

Modus Enum / Namespace Merge

Sie können einen Namespace mit der Aufzählung zusammenführen, um mit zusätzlichen Methoden eine Aufzählung zu erstellen:

enum Mode {
    X,
    Y
}

namespace Mode {
    export function toString(mode: Mode): string {
        return Mode[mode];
    }

    export function parse(mode: string): Mode {
        return Mode[mode];
    }
}

const mode = Mode.X;

const str = Mode.toString(mode);
alert(str);

const m = Mode.parse(str);
alert(m);

Sie können den Zeichenfolgenwert einer nicht konstanten Aufzählung mithilfe eckiger Klammern abrufen:

class Device {
    constructor(public mode:Mode) {
        console.log(Mode[this.mode]);
    }
}

Sie können auch einige enumspezifische Util-Funktionen in die Enum einfügen, aber das ist genau wie bei statischen Klassenmitgliedern:

enum Mode {
    landscape,
    portrait
}

namespace Mode {
    export function doSomething(mode:Mode) {
        // your code here
    }
}

Konvertieren Sie Ihre enumin das Aufzählungsmuster. Ich finde, dass dies im Allgemeinen für viele Sprachen eine bessere Vorgehensweise ist, da Sie ansonsten die Kapselungsoptionen für Ihren Typ einschränken. Die Tendenz ist, switchauf den Aufzählungswert zu setzen, wenn wirklich alle Daten oder Funktionen, die von dem bestimmten Aufzählungswert abhängen, nur in jede Instanz der Aufzählung eingehen sollten. Ich habe etwas mehr Code hinzugefügt, um zu demonstrieren.

Dies funktioniert möglicherweise nicht, wenn Sie besonders von den zugrunde liegenden Aufzählungswerten abhängig sind. In diesem Fall müssten Sie ein Mitglied für die alten Werte hinzufügen und Orte konvertieren, die es benötigen, um die neue Eigenschaft zu verwenden.

class Mode {
   public static landscape = new Mode(1920, 1080);
   public static portrait = new Mode(1080, 1920);

   public get Width(): number { return this.mWidth; }
   public get Height(): number { return this.mHeight; }

   // private constructor if possible in a future version of TS
   constructor(
      private mWidth: number,
      private mHeight: number
   ) {
   }

   public GetAspectRatio() {
      return this.mWidth / this.mHeight;
   }
}

kann enum wie durch privaten Konstruktor und statisches get return Objekt machen

export class HomeSlideEnum{

  public static get friendList(): HomeSlideEnum {

    return new HomeSlideEnum(0, "friendList");

  }
  public static getByOrdinal(ordinal){
    switch(ordinal){
      case 0:

        return HomeSlideEnum.friendList;
    }
  }

  public ordinal:number;
  public key:string;
  private constructor(ordinal, key){

    this.ordinal = ordinal;
    this.key = key;
  }


  public getTitle(){
    switch(this.ordinal){
      case 0:

        return "Friend List"
      default :
        return "DChat"
    }
  }

}

dann kann später so verwendet werden

HomeSlideEnum.friendList.getTitle();

Eine Ergänzung zu Fentons Lösung. Wenn Sie diesen Enumerator in einer anderen Klasse verwenden möchten, müssen Sie sowohl die Aufzählung als auch den Namespace exportieren. Es würde so aussehen:

export enum Mode {
    landscape,
    portrait
}

export namespace Mode {
    export function toString(mode: Mode): string {
        return Mode[mode];
    }
}

Dann importieren Sie einfach die Datei mode.enum.ts in Ihre Klasse und verwenden sie.