如何在Typescript中扩展匿名类型

将

typescript

中的功能链接到匿名类型时，例如：

  let array = [{ seed: 2 }, { seed: 3 }];
  array
    .map(i => ({ seed: i.seed, square: i.seed * i.seed }))
    .forEach(i => console.log(`square for ${i.seed} is ${i.square}`));

我需要为map函数定义新的匿名类型。如果我有多个步骤来生成新的属性，我最终会编写大量的定义代码来继承所有属性。 我可以使用

$.extend

（或

Object.assign

），但那样我将失去智能感知和强大的键入功能

  array
    .map(i => $.extend(i, { square: i.seed * i.seed }))
    .forEach(i => console.log(`square for ${i.seed} is ${i.square}`));

function extend<T, U>(first: T, second: U): T & U {
    let result = <T & U>{};
    for (let id in first) {
        (<any>result)[id] = (<any>first)[id];
    }
    for (let id in second) {
        if (!result.hasOwnProperty(id)) {
            (<any>result)[id] = (<any>second)[id];
        }
    }
    return result;
}

let array = [{ seed: 2 }, { seed: 3 }];

array
    .map(i => extend(i, { square: i.seed * i.seed }))
    .map(i => extend(i, { cube: i.square * i.seed }))
    .forEach(i => console.log(`square for ${i.seed} is ${i.square} and cube is ${i.cube}`));

如何扩展匿名对象而不重新定义所有属性，同时保持强类型？

如何：

interface A {
    seed: number;
}

interface B extends A {
    square: number;
}

let array: A[] = [{ seed: 2 }, { seed: 3 }];
array
    .map<B>(a => { 
        return { seed: a.seed, square: a.seed * a.seed } 
    })
    .forEach(b => console.log("square for ${b.seed} is ${b.square}"));

接口A{
种子数；
}
接口B扩展了A{
正方形：数字；
}
let数组：A[]=[{seed:2}，{seed:3}]；
排列
.map（a=>{
return{seed:a.seed，square:a.seed*a.seed}
})
.forEach（b=>console.log（“square for${b.seed}是${b.square}”）；

或者（如果你想匿名）：

let数组=[{seed:2}，{seed:3}]；
排列
.map（a=>{
return{seed:a.seed，square:a.seed*a.seed}
})
.forEach（b=>console.log（“square for${b.seed}是${b.square}”）；

---

（在中使用）

我终于找到了解决方案。这可以通过以下方式实现。这些可以与匿名类型和类一起使用。在下面的示例中，“扩展”函数将复制每个对象的特性，并返回交叉点类型的对象。这将减少相当数量的类型定义代码，而不会丢失智能感知和强类型

  array
    .map(i => $.extend(i, { square: i.seed * i.seed }))
    .forEach(i => console.log(`square for ${i.seed} is ${i.square}`));

function extend<T, U>(first: T, second: U): T & U {
    let result = <T & U>{};
    for (let id in first) {
        (<any>result)[id] = (<any>first)[id];
    }
    for (let id in second) {
        if (!result.hasOwnProperty(id)) {
            (<any>result)[id] = (<any>second)[id];
        }
    }
    return result;
}

let array = [{ seed: 2 }, { seed: 3 }];

array
    .map(i => extend(i, { square: i.seed * i.seed }))
    .map(i => extend(i, { cube: i.square * i.seed }))
    .forEach(i => console.log(`square for ${i.seed} is ${i.square} and cube is ${i.cube}`));

函数扩展（第一个：T，第二个：U）：T&U{
让结果={}；
for（让id先输入）{
(

这是在f.e.及其返回交叉口类型中实现的：

assign<T, U>(target: T, source: U): T & U;

assign（目标：T，来源：U）：T&U；
您仍然在返回值中再次定义seed。如果有5个参数，map将添加1个参数。这将是一个多么混乱的局面啊。@JukkaVaris，所以使用第一个解决方案和接口。没有办法（我知道）要以其他方式扩展它，我很担心。我的实际用例是RxJS，链可能相当长。接口图很容易失控。我使用匿名类型来减少需要编写的代码量，我希望编译器能够从使用情况推断类型。@JukkaVaris typescript的全部目的是声明types，如果你不想经历这么多的麻烦，那就用javascript吧。是的，用接口定义所有类型会更加冗长，但你会得到好处。如果你现在使用的是最新的typescript，1.8，你不需要显式声明所有类型。有一个叫做上下文类型的概念，它将er类型用于函数参数。因此，与我的原始示例相比，您的第二个示例有很多开销。您能分享一个如何导入和使用核心js实现的示例吗？这将帮助像我这样不想在项目中引入自己的extend（）函数定义的人。谢谢！