Cómo crear objetos de clases en un directorio utilizando Typescript.

27 May, 2023 Programación 0

Digamos que tengo un directorio como el siguiente:

Figuras/
  Cuadrado.ts
  Círculo.ts
  Rectángulo.ts

Mi objetivo es tener un Map o un objeto que tenga el nombre del archivo sin la extensión como clave, y la clase en sí dentro del archivo como el valor que puedo inicializar usando la palabra clave new.

Por ejemplo:

import Application from './Application' // Supuestamente mi punto de entrada de aplicación

let instancias: Map<string, figura=""> = Application.getShapes() // Espero que `getShapes` devuelva un `Map` como se describió anteriormente.

let cuadrado = new instancias.get("Cuadrado") // Espero tener una instancia de Cuadrado

Así que estoy tratando de evitar usar este enfoque y tenerlos creados dinámicamente.

import AlnumRule from './Rules/AlnumRule'
import Rule from './Rules/Contracts/Rule'
import RequiredRule from './Rules/RequiredRule'

export default class RulesMapper {
  static map: { [index: string]: Rule } = {
    required: new RequiredRule(),
    alnum: new AlnumRule(),
  }

  static resolve(rule: string): Rule {
    return RulesMapper.map[rule]
  }
}

En otras palabras, estoy tratando de leer todos los archivos dentro de un directorio determinado y almacenar las clases constructibles en un objeto o un Map.</string,>

davy.ai

May 27, 2023 at 1:33 pm

Para leer de manera dinámica todos los archivos dentro de un directorio y almacenar las clases constructibles en un objeto o en un Map en TypeScript, podemos utilizar el módulo fsy la función require para importar y crear instancias de las clases.

Primero, importamos el módulo fs:

import * as fs from 'fs';

Luego, definimos una función getConstructibleClasses que tome como argumento una ruta de directorio:

function getConstructibleClasses(directoryPath: string): { [index: string]: any } {
  const files = fs.readdirSync(directoryPath); // lee todos los archivos en el directorio
  const constructibleClasses: { [index: string]: any } = {}; // objeto para almacenar las clases constructibles

  for (let file of files) {
    if (file.endsWith('.js') || file.endsWith('.ts')) { // verifica si el archivo es de JavaScript o TypeScript
      const className = file.slice(0, -3); // elimina la extensión del archivo del nombre de la clase
      const classModule = require(`${directoryPath}/${file}`); // requerimos el módulo de la clase
      constructibleClasses[className] = classModule[className]; // añadimos la clase al objeto
    }
  }

  return constructibleClasses; // devuelve el objeto con las clases constructibles
}

Ahora podemos utilizar esta función para obtener un objeto que contenga todas las clases constructibles en un directorio. Para inicializar una clase, simplemente llamamos al constructor de la clase en el objeto que devuelve getConstructibleClasses.

Por ejemplo, utilizando el directorio Shapes mencionado anteriormente:

const directoryPath = './Shapes';
const constructibleClasses = getConstructibleClasses(directoryPath);
const square = new constructibleClasses['Square']();

Esto creará una nueva instancia de la clase Square del directorio Shapes. También podemos utilizar un Map en lugar de un objeto para almacenar las clases constructibles:

function getConstructibleClasses(directoryPath: string): Map<string, any=""> {
  const files = fs.readdirSync(directoryPath);
  const constructibleClasses = new Map<string, any="">();

  for (let file of files) {
    if (file.endsWith('.js') || file.endsWith('.ts')) {
      const className = file.slice(0, -3);
      const classModule = require(`${directoryPath}/${file}`);
      constructibleClasses.set(className, classModule[className]);
    }
  }

  return constructibleClasses;
}

const directoryPath = './Shapes';
const constructibleClasses = getConstructibleClasses(directoryPath);
const square = new constructibleClasses.get('Square')();

Aquí, getConstructibleClasses devuelve un Map con los nombres de clase como claves y los constructores correspondientes como valores. Podemos acceder al constructor de una clase llamando al método get en el Map.</string,></string,>

es.davy.ai

¿Tienes una pregunta?

Cómo crear objetos de clases en un directorio utilizando Typescript.

Answer

davy.ai