Typescript 如何在泛型函数类型中具有可选参数类型？

我有一个通用函数类型，如下所示：

type Test<TArg> = (arg: TArg) => void;

y1();

但无论我为

TArg

插入什么类型的插件，我似乎都无法做到这一点。在

Test

的定义中，是否可以在不使参数可选的情况下执行此操作

以下是我尝试过的：

type Test<TArg> = (arg: TArg) => void;

let x: Test<number> = (n) => { console.log(n) };
let y1: Test<never> = () => { };
let y2: Test<any> = () => { };
let y3: Test<undefined> = () => { };
let y4: Test<null> = () => { };

x(1);
y1(); //Expected 1 arguments, but got 0.
y2(); //Expected 1 arguments, but got 0.
y3(); //Expected 1 arguments, but got 0.
y4(); //Expected 1 arguments, but got 0.

type Test=（arg:target）=>void；
设x:Test=（n）=>{console.log（n）}；
设y1:Test=（）=>{}；
设y2:Test=（）=>{}；
设y3:Test=（）=>{}；
设y4:Test=（）=>{}；
x（1）；
y1（）//应为1个参数，但得到0。
y2（）//应为1个参数，但得到0。
y3（）//应为1个参数，但得到0。
y4（）//应为1个参数，但得到0。

如果可以使用执行包装器，我已经提出了一个解决方案，可以处理函数长度（0或1），并且对于参数是类型安全的：

type Test<T> = (arg?: T) => void;

class Wrapper<T, F extends Test<T>> {
    public execute: F;

    public static create<T1, F1 extends Test<T1>>(method: F1): Wrapper<T1, F1> {
        return new Wrapper(method);
    }

    constructor(method: F) {
        this.execute = method;
    }
}

const func1 = Wrapper.create((a: string) => console.log(a));
const func2 = Wrapper.create(() => { });

func1.execute('3');
func2.execute();

func1.execute(5); // 5 is not assignable to type "string"
func1.execute(); // expected 1 argument
func2.execute(5); // expected 0 arguments

type Test=（arg？：T）=>void；
类包装器{
公共执行：F；
公共静态创建（方法：F1）：包装器{
返回新的包装器（方法）；
}
构造函数（方法：F）{
this.execute=方法；
}
}
const func1=Wrapper.create（（a:string）=>console.log（a））；
const func2=Wrapper.create（（）=>{}）；
功能1.执行（'3'）；
func2.execute（）；
函数1.执行（5）；//5不可分配给类型“字符串”
func1.execute（）；//应为1个参数
函数2.执行（5）；//应为0个参数

注意：如果您想将该参数扩展到1个参数之外，您可以添加其他泛型类型，但必须手动定义每个泛型类型并将其带到包装器类中，但这是可行的

---

编辑删除原始可选参数解决方案

有时有参数，有时没有参数是可选函数参数的定义。为什么不让它成为可选的呢？对于

y3

我可以想象你想不带参数地调用它，但是为什么不带参数地调用

y2

和

y4

是个好主意呢

null

和

any

是带有实例的具体类型，不发送参数是没有意义的。对于

y3

，使其简单可选。基本上，当

TArg=（字符串|数字|对象）

等时，它是必需的。我正在寻找某种类型的

target

，它不需要我在调用站点传递值。@Wickoo是的，你是对的。我只是提供我已经尝试过的代码<代码>从不从逻辑上看它应该工作，但它没有。FWIW我认为这在目前是不可能的。然而，如果有机会登陆，您可能可以使用该功能在这里获得您想要的东西。

type Test<TArg> = (arg: TArg) => void;

let x: Test<number> = (n) => { console.log(n) };
let y1: Test<never> = () => { };
let y2: Test<any> = () => { };
let y3: Test<undefined> = () => { };
let y4: Test<null> = () => { };

x(1);
y1(); //Expected 1 arguments, but got 0.
y2(); //Expected 1 arguments, but got 0.
y3(); //Expected 1 arguments, but got 0.
y4(); //Expected 1 arguments, but got 0.

type Test<T> = (arg?: T) => void;

class Wrapper<T, F extends Test<T>> {
    public execute: F;

    public static create<T1, F1 extends Test<T1>>(method: F1): Wrapper<T1, F1> {
        return new Wrapper(method);
    }

    constructor(method: F) {
        this.execute = method;
    }
}

const func1 = Wrapper.create((a: string) => console.log(a));
const func2 = Wrapper.create(() => { });

func1.execute('3');
func2.execute();

func1.execute(5); // 5 is not assignable to type "string"
func1.execute(); // expected 1 argument
func2.execute(5); // expected 0 arguments