通过 key 跨 typescript 对象执行操作答案

【问题标题】：Performing operations across typescript objects by key通过 key 跨 typescript 对象执行操作
【发布时间】：2022-02-14 14:46:36
【问题描述】：

在打字稿中，我有两个具有匹配键的对象，值的类型为number[][]，例如：

const A = {
    "X": [ [100, 20], [200, 35], [300, 30] ],
    "Y": [ [400, 20], [500, 15], [600, 25] ],
    "Z": [ [700, 30], [800, 35], [900, 40] ]
}

const B = {
    "X": [ [100, 2], [200, 3], [300, 2] ],
    "Y": [ [400, 1], [500, 3], [600, 2] ],
    "Z": [ [700, 3], [800, 3], [900, 2], [1000, 4 ]
}

我想要一个函数，它能够匹配每个对象中的键，根据内部数组中的第一个条目合并值，然后最后对数组中的第二个条目执行操作，例如将值相乘。

所需的输出将是与 A 和 B 格式相同的第三个对象，如下所示：

C = A * B

const C = {
    "X": [ [100, 40], [200, 105], [300, 60] ],
    "Y": [ [400, 20], [500, 45], [600, 50] ],
    "Z": [ [700, 90], [800, 105], [900, 160] ]
}

注意，由于“1000”的值只出现在B中，所以不包含在C中

这是我目前的尝试：

C =  Object.keys(A).reduce((o,key)  => ({ ...o, [key]: A.key[1]*B.key[1]}), {})

但是，我收到错误消息“无法读取未定义的属性（读取 '1'）”

这里的任何帮助将不胜感激！

【问题讨论】：

另外，请注意...用uppercase 命名变量不是idiomatic。通常，type(s) 在Typescript 中以这种方式命名。

标签： typescript object key-value

【解决方案1】：

你可以试试这个，希望对你有帮助

const A = {
  X: [
    [100, 20],
    [200, 35],
    [300, 30],
  ],
  Y: [
    [400, 20],
    [500, 15],
    [600, 25],
  ],
  Z: [
    [700, 30],
    [800, 35],
    [900, 40],
  ],
};

const B = {
  X: [
    [100, 2],
    [200, 3],
    [300, 2],
  ],
  Y: [
    [400, 1],
    [500, 3],
    [600, 2],
  ],
  Z: [
    [700, 3],
    [800, 3],
    [900, 2],
    [1000, 4],
  ],
};

const operation = (a, b) => a * b;

const mergeArrays = (arr1, arr2) => {
  const newArr = [];
  arr1.forEach(([key1, val1]) => {
    const val2 = arr2.find(([key2]) => key2 === key1)?.[1];
    if (val2) {
      // if item with the same key exeist in second array
      // pushing pair to new array
      newArr.push([key1, operation(val1, val2)]);
    }
  });
  return newArr;
};

const mergeObjects = (obj1, obj2) => {
  const newObj = {};
  for (const key in obj1) {
    // I assume you want intersection of object keys too
    if (key in obj2) {
      newObj[key] = mergeArrays(obj1[key], obj2[key]);
    }
  }
  return newObj;
};

console.log(mergeObjects(A, B));

.as-console-wrapper{top:0;max-height:100%!important}

【讨论】：

谢谢您，这对您有很大帮助！只剩下一件事，那就是说 object 可能在 const val2 = arr2.find(([key2]) => key2 === key1)[1];
是的，没错。更好的选择是像这样使用它：const val2 = arr2.find(([key2]) => key2 === key1)?.[1]

【解决方案2】：

打字稿

type Pair<K, V> = [K, V];
type IndexableOf<T> = { [key: string]: T };

function calculate_product(a: IndexableOf<Pair<number, number>[]>, b: IndexableOf<Pair<number, number>[]>): IndexableOf<Pair<number, number>[]> {

  const product: IndexableOf<Pair<number, number>[]> = {};

  Object.keys(a).forEach(key => {
    product[key] =
      pairise(a[key], b[key])
        .map(pair => multiply_pairized(pair))
  });
  return product;

  function multiply_pairs(pair1: Pair<number, number>, pair2: Pair<number, number>): Pair<number, number> {
    return [pair1[0], pair1[1] * (isNaN(pair2[1]) ? 1 : pair2[1])];
  }

  function pairise(arrayOfPairs1: Pair<number, number>[], arrayOfPairs2: Pair<number, number>[]): Pair<Pair<number, number>, Pair<number, number>>[] {
    return arrayOfPairs1.map((pair: Pair<number, number>, index: number) => [pair, arrayOfPairs2[index] || []]);
  }

  function multiply_pairized(pair: Pair<Pair<number, number>, Pair<number, number>>) {
    return multiply_pairs(pair[0], pair[1]);
  }
}

const a: IndexableOf<Pair<number, number>[]> = {
  "X": [[100, 20], [200, 35], [300, 30]],
  "Y": [[400, 20], [500, 15], [600, 25]],
  "Z": [[700, 30], [800, 35], [900, 40]]
};

const b: IndexableOf<Pair<number, number>[]> = {
  "X": [[100, 2], [200, 3], [300, 2]],
  "Y": [[400, 1], [500, 3], [600, 2]],
  "Z": [[700, 3], [800, 3], [900, 2], [1000, 4]]
};

// console.log(calculate_product(a, a));
// console.log(calculate_product(b, b));
console.log(calculate_product(a, b));

插图：Javascript 代码

function calculate_product(a, b) {
  const product = {};
  Object.keys(a).forEach(key => {
    product[key] =
      pairise(a[key], b[key])
      .map(pair => multiply_pairized(pair));
  });
  return product;

  function multiply_pairs(pair1, pair2) {
    return [pair1[0], pair1[1] * (isNaN(pair2[1]) ? 1 : pair2[1])];
  }

  function pairise(arrayOfPairs1, arrayOfPairs2) {
    return arrayOfPairs1.map((pair, index) => [pair, arrayOfPairs2[index] || []]);
  }

  function multiply_pairized(pair) {
    return multiply_pairs(pair[0], pair[1]);
  }
}

const a = {
  "X": [
    [100, 20],
    [200, 35],
    [300, 30]
  ],
  "Y": [
    [400, 20],
    [500, 15],
    [600, 25]
  ],
  "Z": [
    [700, 30],
    [800, 35],
    [900, 40]
  ]
};

const b = {
  "X": [
    [100, 2],
    [200, 3],
    [300, 2]
  ],
  "Y": [
    [400, 1],
    [500, 3],
    [600, 2]
  ],
  "Z": [
    [700, 3],
    [800, 3],
    [900, 2],
    [1000, 4]
  ]
};

// console.log(calculate_product(a, a));
// console.log(calculate_product(b, b));
console.log(calculate_product(a, b));

WYSIWYG => WHAT YOU SHOW IS WHAT YOU GET

【讨论】：