Javascript 用typescript扩展方法

我创建了一个

FileHandler

类，其中包含读取一个或多个类似文件的方法

export class FileHandler {
    private static async readFileFromFileQuery (fq: FileQuery): Promise<File> {
        const { path, encoding, flag } = FileQueryHandler.make(fq);
        const content = await promisify(fs.readFile)(path, { encoding, flag })
        return { path, encoding, flag, content };
    }
    static async readFile (a: Path | FileQuery, b?: Omit<FileQuery, 'path'>): Promise<File> {
        if (typeof a === 'string') a = FileQueryHandler.getFromPath(a, b);
        return FileHandler.readFileFromFileQuery(a);
    }
    static async readFiles (a: (Path | FileQuery)[] | Directory, b?: Omit<FileQuery, 'path'>): Promise<File[]> {        
        if (a instanceof Array) return Promise.all(a.map(p => this.readFile(p, b)));
        return FileHandler.readFiles(PathHandler.getFromDirectory(a), b);
    }
    static async readFilesFromDirectory(a: Path | FileQuery, b?: Omit<FileQuery, 'path'>): Promise<File[]> {
        const ps = await DirectoryHandler.readDirectory(a);    
        if (typeof a === 'string') return await FileHandler.readFiles(ps, b);
        return await FileHandler.readFiles(ps, a);
    }
}

我还想免费获得所有其他方法，因为我看到的是所有原始的

FileHandler

都基于

FileHandler.readFile

我尝试了一些方法将两者转换为不使用

静态

方法，我也尝试了返回类型，但没有什么比简单的方法更容易做到这一点

我需要的是：

• 在两个类中的方法之间具有奇偶性
• 让所有返回值都表示类功能

我正在寻找最好的方法来做到这一点

理想情况下，首先想到的是我能够使用

• 静态

  调用

  此

• ReturnType

但这两种情况都不存在

我想要的是以下结果：

• 返回

  File | null

• FileHandler.readFiles

  返回

  File[]

• 返回

  File[]

• 返回

  （File | null）

• 返回

  （File | null）[

• 返回

  （File | null）[]

---

首先，让类只具有静态属性没有什么意义，这只是构建对象的一种非常复杂的方式：

export const FileHandler = {
   readFile (a: Path | FileQuery, b?: Omit<FileQuery, 'path'>): Promise<File> {
     // ...
   }
};

---

首先，只有静态属性的类没有什么意义，这只是构建对象的一种非常复杂的方式：

export const FileHandler = {
   readFile (a: Path | FileQuery, b?: Omit<FileQuery, 'path'>): Promise<File> {
     // ...
   }
};

---

我发现这种实现这种功能的方法可以维护静态类，但类型在

FileOrNullHandler

中没有正确表示

export function sibling (v) {
    const staticClassName = v.toString().split ('(' || /s+/)[0].split (' ' || /s+/)[1];
    const m = {
        FileHandler,
        FileOrNullHandler
    }
    return m[staticClassName];
}

export class FileHandler {
    static async readFileFromFileQuery (fq: FileQuery): Promise<File> {
        const { path, encoding, flag } = FileQueryHandler.make(fq);
        const content = await promisify(fs.readFile)(path, { encoding, flag })
        return { path, encoding, flag, content };
    }
    static async readFile (a: Path | FileQuery, b?: Omit<FileQuery, 'path'>): Promise<File> {
        if (typeof a === 'string') a = FileQueryHandler.getFromPath(a, b);
        return sibling(this).readFileFromFileQuery(a);
    }
    static async readFiles (a: (Path | FileQuery)[] | Directory, b?: Omit<FileQuery, 'path'>): Promise<File[]> {        
        if (a instanceof Array) return Promise.all(a.map(p => sibling(this).readFile(p, b)));
        return sibling(this).readFiles(PathHandler.getFromDirectory(a), b);
    }
    static async readFilesFromDirectory(a: Path | FileQuery, b?: Omit<FileQuery, 'path'>): Promise<File[]> {
        const ps = await DirectoryHandler.readDirectory(a);    
        if (typeof a === 'string') return await sibling(this).readFiles(ps, b);
        return await sibling(this).readFiles(ps, a);
    }
}

export class FileOrNullHandler {
    static async readFileFromFileQuery (fq: FileQuery): Promise<File | null> {
        return orNull(() => FileHandler.readFileFromFileQuery(fq));
    }
    static readFile = FileHandler.readFile;
    static readFiles = FileHandler.readFiles;
    static readFilesFromDirectory = FileHandler.readFilesFromDirectory;
}

导出函数同级（v）{
const staticClassName=v.toString（）.split（‘（‘|/s+/）[0]。split（‘|/s+/）[1]；
常数m={
FileHandler，
FileOrNullHandler
}
返回m[staticClassName]；
}
导出类文件处理程序{
静态异步readFileFromFileQuery（fq:FileQuery）：承诺{
const{path，encoding，flag}=FileQueryHandler.make（fq）；
const content=await promisify（fs.readFile）（路径，{encoding，flag}）
返回{path，encoding，flag，content}；
}
静态异步读取文件（a:Path | FileQuery，b？：省略）：承诺{
if（typeof a=='string'）a=FileQueryHandler.getFromPath（a，b）；
返回同级（this）.readFileFromFileQuery（a）；
}
静态异步读取文件（a:（路径|文件查询）[]|目录，b？：省略）：承诺{
if（数组的实例）返回Promise.all（a.map（p=>sibling（this.readFile（p，b））；
返回同级（this）.readFiles（PathHandler.getFromDirectory（a），b）；
}
静态异步readFilesFromDirectory（a:Path | FileQuery，b？：省略）：承诺{
const ps=await DirectoryHandler.readDirectory（a）；
if（typeof a=='string'）返回等待同级（this）.readFiles（ps，b）；
return wait sibling（this）.readFiles（ps，a）；
}
}
导出类FileOrNullHandler{
静态异步readFileFromFileQuery（fq:FileQuery）：承诺{
返回orNull（（）=>FileHandler.readFileFromFileQuery（fq））；
}
静态readFile=FileHandler.readFile；
静态readFiles=FileHandler.readFiles；
静态readFilesFromDirectory=FileHandler.readFilesFromDirectory；
}

我找到了一种实现此功能的方法，可以维护静态类，但类型在

FileOrNullHandler

中没有正确表示

export function sibling (v) {
    const staticClassName = v.toString().split ('(' || /s+/)[0].split (' ' || /s+/)[1];
    const m = {
        FileHandler,
        FileOrNullHandler
    }
    return m[staticClassName];
}

export class FileHandler {
    static async readFileFromFileQuery (fq: FileQuery): Promise<File> {
        const { path, encoding, flag } = FileQueryHandler.make(fq);
        const content = await promisify(fs.readFile)(path, { encoding, flag })
        return { path, encoding, flag, content };
    }
    static async readFile (a: Path | FileQuery, b?: Omit<FileQuery, 'path'>): Promise<File> {
        if (typeof a === 'string') a = FileQueryHandler.getFromPath(a, b);
        return sibling(this).readFileFromFileQuery(a);
    }
    static async readFiles (a: (Path | FileQuery)[] | Directory, b?: Omit<FileQuery, 'path'>): Promise<File[]> {        
        if (a instanceof Array) return Promise.all(a.map(p => sibling(this).readFile(p, b)));
        return sibling(this).readFiles(PathHandler.getFromDirectory(a), b);
    }
    static async readFilesFromDirectory(a: Path | FileQuery, b?: Omit<FileQuery, 'path'>): Promise<File[]> {
        const ps = await DirectoryHandler.readDirectory(a);    
        if (typeof a === 'string') return await sibling(this).readFiles(ps, b);
        return await sibling(this).readFiles(ps, a);
    }
}

export class FileOrNullHandler {
    static async readFileFromFileQuery (fq: FileQuery): Promise<File | null> {
        return orNull(() => FileHandler.readFileFromFileQuery(fq));
    }
    static readFile = FileHandler.readFile;
    static readFiles = FileHandler.readFiles;
    static readFilesFromDirectory = FileHandler.readFilesFromDirectory;
}

导出函数同级（v）{
const staticClassName=v.toString（）.split（‘（‘|/s+/）[0]。split（‘|/s+/）[1]；
常数m={
FileHandler，
FileOrNullHandler
}
返回m[staticClassName]；
}
导出类文件处理程序{
静态异步readFileFromFileQuery（fq:FileQuery）：承诺{
const{path，encoding，flag}=FileQueryHandler.make（fq）；
const content=await promisify（fs.readFile）（路径，{encoding，flag}）
返回{path，encoding，flag，content}；
}
静态异步读取文件（a:Path | FileQuery，b？：省略）：承诺{
if（typeof a=='string'）a=FileQueryHandler.getFromPath（a，b）；
返回同级（this）.readFileFromFileQuery（a）；
}
静态异步读取文件（a:（路径|文件查询）[]|目录，b？：省略）：承诺{
if（数组的实例）返回Promise.all（a.map（p=>sibling（this.readFile（p，b））；
返回同级（this）.readFiles（PathHandler.getFromDirectory（a），b）；
}
静态异步readFilesFromDirectory（a:Path | FileQuery，b？：省略）：承诺{
const ps=await DirectoryHandler.readDirectory（a）；
if（typeof a=='string'）返回等待同级（this）.readFiles（ps，b）；
return wait sibling（this）.readFiles（ps，a）；
}
}
导出类FileOrNullHandler{
静态异步readFileFromFileQuery（fq:FileQuery）：承诺{
返回orNull（（）=>FileHandler.readFileFromFileQuery（fq））；
}
静态readFile=FileHandler.readFile；
静态readFiles=FileHandler.readFiles；
静态readFilesFromDirectory=FileHandler.readFilesFromDirectory；
}

静态类方法似乎可以使用

this

并进行扩展。但是类型仍然不准确

export class FileHandler {
    static async readFileFromFileQuery (fq: FileQuery): Promise<File> {
        const { path, encoding, flag } = FileQueryHandler.make(fq);
        const content = await promisify(fs.readFile)(path, { encoding, flag })
        return { path, encoding, flag, content };
    }
    static async readFile (a: Path | FileQuery, b?: Omit<FileQuery, 'path'>): Promise<File> {
        if (typeof a === 'string') a = FileQueryHandler.getFromPath(a, b);
        return this.readFileFromFileQuery(a);
    }
    static async readFiles (a: (Path | FileQuery)[] | Directory, b?: Omit<FileQuery, 'path'>): Promise<File[]> {        
        if (a instanceof Array) return Promise.all(a.map(p => this.readFile(p, b)));
        return this.readFiles(PathHandler.getFromDirectory(a), b);
    }
    static async readFilesFromDirectory(a: Path | FileQuery, b?: Omit<FileQuery, 'path'>): Promise<File[]> {
        const ps = await DirectoryHandler.readDirectory(a);    
        if (typeof a === 'string') return await this.readFiles(ps, b);
        return await this.readFiles(ps, a);
    }
}

export class FileOrNullHandler extends FileHandler {
    static async readFileFromFileQuery (fq: FileQuery): Promise<File | null> {
        return orNull(() => FileHandler.readFileFromFileQuery(fq));
    }
}

导出类文件处理程序{
静态异步readFileFromFileQuery（fq:FileQuery）：承诺{
const{path，encoding，flag}=FileQueryHandler.make（fq）；
const content=await promisify（fs.readFile）（路径，{encoding，flag}）
返回{path，encoding，flag，content}；
}
静态异步读取文件（a:Path | FileQuery，b？：省略）：承诺{
if（typeof a=='string'）a=FileQueryHandler.getFromPath（a，b）；