enums - TypeScript: agregar funciones a un Enum

numeric enums typescript

Question

¿Es posible agregar funciones a un tipo Enum en TypeScript?

por ejemplo:

enum Mode {
    landscape,
    portrait,

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

O:

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

enum Mode extends ModeExtension {
    landscape,
    portrait,
}

Por supuesto, la función toString() contendría algo como un switch Pero un caso de uso fluiría a lo largo de las líneas de:

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

Entiendo por qué extender una enum puede ser algo extraño, solo me pregunto si es posible.

Answer 1

Convierte tu enum al patrón de enumeración. Creo que esta es una mejor práctica en general para muchos idiomas, ya que de lo contrario restringe las opciones de encapsulación para su tipo. La tendencia es switch el valor de enumeración, cuando en realidad, cualquier dato o funcionalidad que dependa del valor de enumeración en particular debe ingresar en cada instancia de la enumeración. He añadido un poco más de código para demostrar.

Esto podría no funcionar si eres particularmente dependiente de los valores de enumeración subyacentes. En ese caso, deberá agregar un miembro para los valores antiguos y convertir los lugares que lo necesiten para usar la nueva propiedad.

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;
   }
}

Answer 2

Puede obtener el valor de cadena de una enumeración no constante utilizando corchetes:

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

También puede poner algunas funciones de utilidad específicas de la enumeración en la enumeración, pero eso es como miembros de clase estática:

enum Mode {
    landscape,
    portrait
}

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

Answer 3

Puede tener una clase que está separada de la Enum y usarla para obtener las cosas que desea, o puede combinar un espacio de nombres en la Enum y obtener todo en el mismo lugar.

Modo de clase de utilidad

Así que esto no es exactamente lo que está buscando, pero le permite encapsular el comportamiento de "Modo a cadena" utilizando un método estático.

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

Puedes usarlo así:

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

Modo Enum / Namespace Merge

Puede combinar un espacio de nombres con el Enum para crear lo que parece un Enum con métodos adicionales:

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);

Answer 4

puede hacer enumeración como por constructor privado y objeto estático obtener retorno

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"
    }
  }

}

luego puede usarlo así

HomeSlideEnum.friendList.getTitle();