Estoy tratando de construir un mapa de tipos y devoluciones de llamadas, así que comencé con una estructura como esta:
type Instantiable<T = unknown> = new (...args: any[]) => T; type SingleParamFn<TInput = unknown, TOuput = unknown> = (arg: TInput) => TOuput; type TypesRecord<T> = { type: Instantiable<T>, callback: SingleParamFn<T> }; type TypesMap = TypesRecord[]; // This is the structureUn ejemplo de esto:
const myMap: TypesMap = [{ type: Date, callback: (value) => 'this is a Date' }];Esto parece funcionar como se esperaba, pero me di cuenta de que es un poco ineficiente ya que necesita hacer un bucle en la matriz para encontrar el tipo que desea.
Empecé a jugar con tener los tipos como claves de objeto y parece funcionar al menos en Google Chrome:
class MyFancyObject {} class MyOtherObject {} const map = { [Date]: () => 'this is a date', [MyFancyObject]: () => 'this is a fancy object', [MyOtherObject]: () => 'this is another object' }; console.log(map[Date]()); // 'this is a date' console.log(map[MyFancyObject]()); // 'this is a fancy object' console.log(map[MyOtherObject]()); // 'this is another object' const obj = new MyFancyObject(); console.log(map[obj.constructor]()); // 'this is a fancy object' console.log(map[(new Date()).constructor]()); // 'this is a date'He estado revisando algo de documentación y parece que la clave de un objeto solo puede ser una cadena o un símbolo , así que verifiqué qué constituye un símbolo y parece ser un poco vago, ya que se define como un objeto integrado cuyo constructor devuelve un símbolo primitivo que se garantiza que es único y el constructor de un objeto es (hasta donde yo sé), único.
Dado todo esto, ¿usar los constructores como claves de objeto es un enfoque confiable? Si es así, ¿cómo puedo definir el tipo de mecanografiado para dicho objeto? Si no es así, ¿hay otras opciones (como el objeto Map )?
Dado todo esto, ¿usar los constructores como claves de objeto es un enfoque confiable?
No. Como dijiste, las claves de un objeto solo pueden ser cadenas o Símbolos . Un Símbolo es un primitivo que se obtiene de una propiedad en Symbol (para Símbolos bien conocidos definidos por especificación) o al llamar a Symbol() o Symbol.for("...") . Las funciones constructoras no son símbolos, son funciones.
Las claves de su objeto de map son cadenas. Cuando usa un nombre de propiedad calculado como [MyFancyObject] , si el valor que proporciona no es una cadena o un símbolo (en su caso, es una función), se convierte en una cadena implícitamente como si lo hubiera hecho String(MyFancyObject) . Se puede ver que aquí:
class MyFancyObject {} class MyOtherObject {} const map = { [Date]: () => 'this is a date', [MyFancyObject]: () => 'this is a fancy object', [MyOtherObject]: () => 'this is another object' }; console.log(Object.keys(map)); console.log(map[MyFancyObject]()); // "this is a fancy object" console.log(map["class MyFancyObject {}"]()); // also "this is a fancy object" Como puede ver, la clave en la que está pensando como MyFancyObject es en realidad la cadena "class MyFancyObject {}" .
Sin embargo, puede usar funciones de constructor como claves en un Map :
class MyFancyObject {} class MyOtherObject {} const map = new Map([ [Date, () => 'this is a date'], [MyFancyObject, () => 'this is a fancy object'], [MyOtherObject, () => 'this is another object'], ]); console.log(map.get(MyFancyObject)());En eso, las claves son realmente las funciones constructoras, no las cadenas derivadas de ellas.