Javascript typescript中相同实现的不同返回类型推断

我想了解为什么以下两种实现之间存在类型差异。它们都生成相同的结果，但它们的返回类型都不同

const from = [
    () => console.log('first'), 
    () => console.log('second'), 
    () => console.log('third')];

const to = {
    first: 1,
    second: 2,
    third: 3,
};

const aggFn = (from: Function[], to: { [as: string]: any }): Record<keyof typeof to, Function> => {
    return ({
        first: from[0],
        second: from[1],
        third: from[2],
    } as unknown) as Record<keyof typeof to, Function>;
};

const agg = aggFn(from, to);

const from=[
（）=>console.log（'first'），
（）=>console.log（'second'），
（）=>console.log（'third'）；
常数至={
第一:1,，
二:二,，
三:三,，
};
const aggFn=（from:Function[]，to:{[as:string]：any}）：记录=>{
返回({
第一：从[0]，
第二：从[1]，
第三：从[2]，
}（未知）作为记录；
};
常量agg=aggFn（从，到）；

此处agg的返回类型为记录，其中为第二个代码

const from = [
    () => console.log('first'), 
    () => console.log('second'), 
    () => console.log('third')];

const to = {
    first: 1,
    second: 2,
    third: 3,
};

const aggFn2 = <T>(from: Function[], to: { [as: string]: any }): T => {
    return ({
        first: from[0],
        second: from[1],
        third: from[2],
    } as unknown) as T;
};

const agg2 = aggFn2<Record<keyof typeof to, Function>>(from, to);

const from=[
（）=>console.log（'first'），
（）=>console.log（'second'），
（）=>console.log（'third'）；
常数至={
第一:1,，
二:二,，
三:三,，
};
const aggFn2=（from:Function[]，to:{[as:string]：any}）：T=>{
返回({
第一：从[0]，
第二：从[1]，
第三：从[2]，
}如未知）如T；
};
常量agg2=aggFn2（从，到）；

---

返回类型为Record

不同之处在于

to

在

typeof to

的两个版本中指的是不同的变量：在第一个代码段中，它指的是

{[as:string]：any}

类型的局部变量，在另一个代码段中，它指的是全局变量

to

。该变量是通过分配给它的值键入的，该值的类型为

{first:string，second:string，third:string}

函数的实际类型应该是（这实际上符合它的行为，并且允许typescript根据

to

参数推断泛型参数）：

（收件人：记录）：记录

因为第一个示例中的

to

是指从外部范围隐藏

to

变量的函数参数。@jcalz有没有一种方法可以获得类型推断，将实际键为

的类型返回到
类似于第一个实现中的
记录
。我试图找出一种方法，用户在调用时不必传递类型，从而获得相同的结果。它将有助于创建
对象并将其传递给
对象（请不要对其进行阴影处理）：@乔纳斯威尔斯请原谅我在这里太天真了。您的意思是不在全局范围内定义
to
变量，而只是将其定义为函数参数吗？如果是这样，即使这样也会导致类型为
Record
的类型推断，谢谢您的帮助。由于我需要为上下文类型输入完成返回类型，因此我可以通过将签名更改为
（to:T）：Record
使其工作，因为现在
T
是从
派生到
，我甚至不需要传递泛型类型
  <T> (to: Record<T, any>): Record<T, Function>