generics - 如何将未指定的泛型函数分配给 TypeScript 中的变量？

Question

如何将未参数化的泛型函数分配给变量？

在下面的示例中，考虑我尝试通过组合通用函数并将组合结果分配给变量来创建 areArraysShallowlyEqual 函数:

export function areNullablesEqualOver<a>(areEqual: (one: a, another: a) => boolean)
:(one: a, another: a) => boolean {
    return function(one, another) {
        if (one == null) {
            if (another == null) {
                return true;
            } else {
                return false;
            }
        } else {
            if (another == null) {
                return false;
            } else {
                return areEqual(one, another);
            }
        }
    };
};

export function areArraysEqualOver<a>(areEqual: (one: a, another: a) => boolean)
: (one: a[], another: a[]) => boolean {
    return function (ones, anothers) {
        var length = ones.length;
        if (length !== anothers.length) return false;
        for (var index = 0; index < length; index++) {
            if (areEqual(ones[index], anothers[index])) continue;
            return false;
        }
        return true;
    }
}

export function areSame<a>(one: a, another: a): boolean {
    return one === another;
}

// PROBLEM:
export var areArraysShallowlyEqual<a> = areNullablesEqualOver<a>(areArraysEqualOver(areSame));

Answer 1

您可以使用通用类来完成此操作。这与您正在做的不完全相同，因为您需要使用类型参数实例化类，而不是将类型参数传递给各个函数 - 但鉴于您不能将类型参数传递给您建议的变量实现是不可能的。

接口(interface)不是必需的，您可以在整个过程中重复类型注释，但它们有助于区分数组和非数组变体。

areArraysEqualOver 和 areNullablesEqualOver 已在 areArraysShallowlyEqual 属性中交换 - 这是因为 areArraysEqualOver 方法不' 返回一个与其他签名兼容的类型，因为它返回一个数组比较器，而所有其他方法都接受一个非数组比较器。

interface EqualityFunction<T> {
    (one: T, another: T) : boolean;
}

interface ArrayEqualityFunction<T> {
    (one: T[], another: T[]) : boolean;
}

class Example<a> {
    areNullablesEqualOver(areEqual: EqualityFunction<a>) : EqualityFunction<a> {
        return function(one, another) {
            if (one == null) {
                if (another == null) {
                    return true;
                } else {
                    return false;
                }
            } else {
                if (another == null) {
                    return false;
                } else {
                    return areEqual(one, another);
                }
            }
        };
    }

    areArraysEqualOver(areEqual: EqualityFunction<a>) : ArrayEqualityFunction<a> {
        return function (ones, anothers) {
            var length = ones.length;
            if (length !== anothers.length) return false;
            for (var index = 0; index < length; index++) {
                if (areEqual(ones[index], anothers[index])) continue;
                return false;
            }
            return true;
        }
    }

    areSame(one: a, another: a): boolean {
        return one === another;
    }

    areArraysShallowlyEqual = this.areArraysEqualOver(this.areNullablesEqualOver(this.areSame));
}

调用代码如下所示:

 var example = new Example<string>();

 example.areArraysShallowlyEqual(['a', 'b'], ['a', 'b']); // true

 example.areArraysShallowlyEqual(['a', 'b'], ['a', 'c']); // false