如何將未指定的通用函數分配給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

你可以做到這一點使用一個通用類。這與你所做的並不完全一樣，因爲你需要用類型實例來實例化類，而不是將類型參數傳遞給單個函數 - 但是，假設你不能將類型參數傳遞給你的變量實現是不可能的。

接口不是必需的，您可以重複整個類型註釋，但它們有助於區分數組和非數組變體。

的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