当一个Map可以接受固定类型的任意值时，使用ES6 Map，否则使用可选属性

我想这就是我的指导方针。ES6映射可以在typescript中完成，如在typescript中提到的:ES6映射

可选属性的主要用例是函数的“选项”参数:使用命名参数JavaScript(基于typescript)在这种情况下，我们确实提前知道允许的属性的确切列表，所以最明智的事情是只定义一个显式接口，只是使任何可选的可选与?正如在https://stackoverflow.com/a/18444150/895245上提到的，尽可能多地进行类型检查:

const assert = require('assert')

interface myfuncOpts {
  myInt: number,
  myString?: string,
}

function myfunc({
  myInt,
  myString,
}: myfuncOpts) {
  return `${myInt} ${myString}`
}

const opts: myfuncOpts = { myInt: 1 }
if (process.argv.length > 2) {
  opts.myString = 'abc'
}

assert.strictEqual(
  myfunc(opts),
  '1 abc'
)

然后，当它是真正任意的(无限多个可能的键)并且具有固定类型时，我将使用Map，例如:

const assert = require('assert')
const integerNames = new Map<number, string>([[1, 'one']])
integerNames.set(2, 'two')
assert.strictEqual(integerNames.get(1), 'one')
assert.strictEqual(integerNames.get(2), 'two')

测试:

  "dependencies": {
    "@types/node": "^16.11.13",
    "typescript": "^4.5.4"
  }

你可以用这个:

this.model = Object.assign(this.model, { newProp: 0 });

可以使用展开操作符在旧对象的基础上创建新对象

interface MyObject {
    prop1: string;
}

const myObj: MyObject = {
    prop1: 'foo',
}

const newObj = {
    ...myObj,
    prop2: 'bar',
}

console.log(newObj.prop2); // 'bar'

TypeScript会推断出原始对象的所有字段，VSCode会自动补全，等等。

我写过一篇文章探讨这个话题:

Typescript -在运行时增强对象及其类型

https://tech.xriba.io/2022/03/24/typescript-enhance-an-object-and-its-type-at-runtime/

也许你可以从Typescript概念中获得灵感，比如:

映射类型 通过as键重映射 十字路口类型

唯一完全类型安全的解决方案是这个，但是有点啰嗦，并且迫使您创建多个对象。

如果你必须先创建一个空对象，那么从这两个解决方案中选择一个。记住，每次你使用as，你就失去了安全。

安全解决方案

对象类型在getObject中是安全的，这意味着对象。A的类型为字符串| undefined

interface Example {
  a: string;
  b: number;
}

function getObject() {
  const object: Partial<Example> = {};
  object.a = 'one';
  object.b = 1;
  return object as Example;
}

短期解决方案

对象类型在getObject中是不安全的，这意味着对象。即使在赋值之前，A的类型也是string。

interface Example {
  a: string;
  b: number;
}

function getObject() {
  const object = {} as Example;
  object.a = 'one';
  object.b = 1;
  return object;
}

我很惊讶没有一个答案引用Object。赋值，因为这是我在考虑JavaScript中的“组合”时使用的技术。

在TypeScript中，它可以像预期的那样工作:

interface IExisting {
    userName: string
}

interface INewStuff {
    email: string
}

const existingObject: IExisting = {
    userName: "jsmith"
}

const objectWithAllProps: IExisting & INewStuff = Object.assign({}, existingObject, {
    email: "jsmith@someplace.com"
})

console.log(objectWithAllProps.email); // jsmith@someplace.com

优势

始终保持类型安全，因为您根本不需要使用任何类型 使用TypeScript的聚合类型(在声明objectWithAllProps类型时用&表示)，这清楚地表明我们正在动态地(即动态地)组合一个新类型。

需要注意的事情

Object.assign has it's own unique aspects (that are well known to most experienced JS devs) that should be considered when writing TypeScript. It can be used in a mutable fashion, or an immutable manner (I demonstrate the immutable way above, which means that existingObject stays untouched and therefore doesn't have an email property. For most functional-style programmers, that's a good thing since the result is the only new change). Object.assign works the best when you have flatter objects. If you are combining two nested objects that contain nullable properties, you can end up overwriting truthy values with undefined. If you watch out for the order of the Object.assign arguments, you should be fine.