Typescript 类型脚本定义文件交集类型函数签名

我偶然发现了一个带有交叉类型函数签名的typescript定义文件。它们来自文件

index.d.ts

中的

@types/croppie

：

result(options: ResultOptions & { type: 'base64' }): Promise<string>;
result(options: ResultOptions & { type: 'html' }): Promise<HTMLElement>;
result(options: ResultOptions & { type: 'blob' }): Promise<Blob>;
result(options: ResultOptions & { type: 'canvas' }): Promise<HTMLCanvasElement>;
result(options?: ResultOptions): Promise<HTMLCanvasElement>;

typescript编译器将

数据

标识为

HTMLCanvasElement

，但实际上是一个base64编码字符串

有人能指出如何正确传递参数，以便typescript编译器将

数据

识别为字符串吗

---

非常感谢。

我猜问题与传递到结果函数的参数的准备方式有关。我对这个准备工作做了一些修改，看起来你提到的代码开始工作了。而不是：

{...opts, ...{type: 'base64'}}

我写道：

{ ...opts, type: 'base64' }

你可以在地图上查看我的例子

下面是示例的完整代码：

class ResultOptions {
    param1: any;
}

class ClassA {
    result(options: ResultOptions & { type: 'base64' }): Promise<string>;
    result(options: ResultOptions & { type: 'html' }): Promise<HTMLElement>;
    result(options: ResultOptions & { type: 'blob' }): Promise<Blob>;
    result(options: ResultOptions & { type: 'canvas' }): Promise<HTMLCanvasElement>;
    result(options?: ResultOptions): Promise<HTMLCanvasElement>;
    result(options?: ResultOptions): Promise<any> {
        if ((options as any).type === "base64") {
            return new Promise<string>(
                (resolve) => {
                    resolve("some string");
                }
            );

        } else {
            return new Promise<any>(
                (resolve) => {
                    resolve({});
                }
            );
        }
    }
}

const opts = new ResultOptions();
const instanceA = new ClassA();
instanceA.result({ ...opts, type: 'base64' })
    .then(
        (data: string) => {
            alert("data(string): " + data);
        }
    );

instanceA.result(opts)
    .then(
        (data: any) => {
            alert("data(any): " + data);
        }
    );

类结果{
参数1：任何；
}
甲级{
结果（选项：ResultOptions&{type:'base64'}）：承诺；
结果（选项：ResultOptions&{type:'html'}）：承诺；
结果（选项：ResultOptions&{type:'blob'}）：Promise；
结果（选项：ResultOptions&{type:'canvas'}）：承诺；
结果（选项？：结果选项）：承诺；
结果（选项？：结果选项）：承诺{
如果（（选项如有）。类型==“base64”）{
回报新的承诺(
（解决）=>{
解析（“某个字符串”）；
}
);
}否则{
回报新的承诺(
（解决）=>{
解析（{}）；
}
);
}
}
}
const opts=新结果选项（）；
const instanceA=new ClassA（）；
result（{…opts，类型：'base64'}）
.那么(
（数据：字符串）=>{
警报（“数据（字符串）：”+数据）；
}
);
instanceA.result（选项）
.那么(
（数据：任何）=>{
警报（“数据（任何）：”+数据）；
}
);

哦，就这么简单。事实上，当我没有使用另一个内部对象时，编译器会正确地识别它。非常感谢你的回答，漂亮的作品！

class ResultOptions {
    param1: any;
}

class ClassA {
    result(options: ResultOptions & { type: 'base64' }): Promise<string>;
    result(options: ResultOptions & { type: 'html' }): Promise<HTMLElement>;
    result(options: ResultOptions & { type: 'blob' }): Promise<Blob>;
    result(options: ResultOptions & { type: 'canvas' }): Promise<HTMLCanvasElement>;
    result(options?: ResultOptions): Promise<HTMLCanvasElement>;
    result(options?: ResultOptions): Promise<any> {
        if ((options as any).type === "base64") {
            return new Promise<string>(
                (resolve) => {
                    resolve("some string");
                }
            );

        } else {
            return new Promise<any>(
                (resolve) => {
                    resolve({});
                }
            );
        }
    }
}

const opts = new ResultOptions();
const instanceA = new ClassA();
instanceA.result({ ...opts, type: 'base64' })
    .then(
        (data: string) => {
            alert("data(string): " + data);
        }
    );

instanceA.result(opts)
    .then(
        (data: any) => {
            alert("data(any): " + data);
        }
    );