如何在将布尔累加器作为初始值的同时将 array.prototype.reduce() 与 TypeScript 一起使用？

Question

我正打算在 binarysearch.io 上解决一些算法并遇到了这个问题：

我用JS解决了如下：

class Solution {
    solve(nums) {
        const Hash = {};
        const Cache = {};
        
        for (let val of nums) {
            if (!Hash[val]) {
                Hash[val] = 0;
            }
            Hash[val]++; //implicit else
        }

        const result = Object.values(Hash).reduce((accum, curr) => {
            if (accum && Cache[curr] !== 'unique') {
                Cache[curr] = 'unique';
                return true
            }
            return false;
        }, true);
        
        return result;
    }
}

但是，当我尝试使用 TypeScript 解决它时，我对它还很陌生，并且遇到了可能由 .reduce() 方法引起的编译错误：

class Solution {
    solve(nums: Array<number>): boolean {
        const Hash = {};
        const Cache = {};
        
        for (let val of nums) {
            if (!Hash[val]) {
                Hash[val] = 0;
            }
            Hash[val]++; //implicit else
        }
        
        const val_arr = Object.values(Hash);

        return val_arr.reduce((accum, curr) => {
            if (accum && Cache[curr] !== 'unique') {
                Cache[curr] = 'unique';
                return true;
            }
            return false;
        }, true);
    }
}

我不确定如何为种子初始值的 .reduce() 方法提供 return 类型。我已经尝试将初始值更改为布尔类型，但我仍然遇到编译错误：

return val_arr.reduce((accum, curr) => {
            if (accum && Cache[curr] !== 'unique') {
                Cache[curr] = 'unique';
                return true;
            }
            return false;
        }, true as boolean);

我试着搜索是否还有其他人有这个问题，但我发现的大多数帖子都以对象作为初始值，所以我不太明白。看起来最简单的解决方案似乎是在不使用 .reduce() 的情况下重构来解决这个问题，但我只是想知道如何为上述 JS 解决方案创建一个 TS 'equivalent'。

Answer 1

你需要

(1) 正确键入Hash对象，以便TS

可以识别其键和值的类型

(2) 正确键入Cache对象，以便TS

能够识别其键和值的类型

(3) 将累加器键入 boolean，而不是 true，以便内部回调可以 return true 或 false . （这可以通过将 <boolean> 作为类型参数传递给 .reduce 来完成——使用泛型比 as 更可取）

class Solution {
    solve(nums: Array<number>): boolean {
        const Hash: {[key: number]: number} = {};
        const Cache: {[key: number]: string} = {};
        
        for (let val of nums) {
            if (!Hash[val]) {
                Hash[val] = 0;
            }
            Hash[val]++; //implicit else
        }
        
        const val_arr = Object.values(Hash);

        return val_arr.reduce<boolean>((accum, curr) => {
            if (accum && Cache[curr] !== 'unique') {
                Cache[curr] = 'unique';
                return true;
            }
            return false;
        }, true);
    }
}

另一件需要考虑的事情 - Java脚本不是 Java。如果你有一个 class 只包含一个方法，没有对实例变量的引用，那么在结构上定义一个普通函数会更有意义，例如：

function solve(nums: Array<number>) {
  // function implementation
}

如何在将布尔累加器作为初始值的同时将 array.prototype.reduce() 与 TypeScript 一起使用？

How to use array.prototype.reduce() with TypeScript while having a boolean accumulator as the initial value?

javascript

reduce

static

types

typescript