如何在TypeScript中使用array.prototype.reduce()并将布尔值作为初始值？

Question

如何在TypeScript中使用array.prototype.reduce()并将布尔值作为初始值？

5

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

我使用JavaScript解决了它，代码如下：

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 val_arr.reduce((accum, curr) => {
            if (accum && Cache[curr] !== 'unique') {
                Cache[curr] = 'unique';
                return true;
            }
            return false;
        }, true as boolean);

我尝试搜索是否有其他人也遇到这个问题，但我找到的大多数帖子的初始值都是对象，所以我不太能理解它。最简单的解决方案似乎是重构以不使用 .reduce() 来解决此问题，但我只想知道如何创建一个与前面提到的 JS 解决方案“等效”的 TS 解决方案。

- Shah

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- CertainPerformance · Accepted Answer

您需要：

(1) 正确地输入 Hash 对象，以便 TS 可以识别其键和值的类型。

(2) 正确地输入 Cache 对象，以便 TS 可以识别其键和值的类型。

(3) 将累加器的类型标记为 boolean，而不是 true，以便回调函数可以返回 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);
    }
}

还有一点需要考虑——JavaScript并不是Java。如果你有一个只包含单个方法且没有对实例变量的引用的类，为了结构上更合理，定义一个普通函数会更加合适，例如：

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