打字稿：如何定义可调用对象？

Question

This comes from @types/d3:

export interface ScaleContinuousNumeric<Range, Output> {
    (value: number | { valueOf(): number }): Output;

but that's an interface. How do I define a class, the instances of which can be invoked like functions? Something like this:

const inverter = new Inverter();
const question = inverter(42);

Maybe there is some kind of special ES6 Symbol like

class Inverter {
    [Symbol.invokable]() {

    }
}

or TypeScript syntax?

Answer 1

You just define a regular function, that will satisfy the interface with the call signature:

export interface ScaleContinuousNumeric<Range, Output> {
    (value: number | { valueOf(): number }): Output;
}

let a : ScaleContinuousNumeric<number, string> = (value) => value.toString()

If the interface has other methods you can use Object.assign to create the function and add the properties:

export interface ScaleContinuousNumeric<Range, Output> {
    (value: number | { valueOf(): number }): Output;
    otherValue: Range
}

let a: ScaleContinuousNumeric<number, string> = Object.assign(
    (value: number | { valueOf(): number }) => value.toString(), {
        otherValue: 1
    });

Or in typescript 3.0 you can create the function, assign the extra properties and then the function will be compatible with the interface:

export interface ScaleContinuousNumeric<Range, Output> {
    (value: number | { valueOf(): number }): Output;
    otherValue: Range
}

function myFunc(value: number | { valueOf(): number }) {
    return value.toString()
}
myFunc.otherValue = 1
let a: ScaleContinuousNumeric<number, string> = myFunc

Answer 2

I had a similar problem. I needed to implement a custom scale in Typescript. The following worked.

let scaleLinear = function () {

    // To translate from domain [a, b] to range [c, d] we use:
    // y = x.m + n;
    // where
    // m = (c - d)/(a - b)
    // n = (a.d - b.c)/(a - b)
    //
    let _range = [0, 1];
    let _domain = [0, 1];
    let _clamp = false;
    let _m = 1.0;
    let _n = 0.0;

    function scale(value: number) {
        return value * _m + _n;
    }

    scale.rescale = function () {
        // Called internally to recalc scale values
        _m = (_range[0] - _range[1]) / (_domain[0] - _domain[1]);
        _n = (_domain[0] * _range[1] - _domain[1] * _range[0]) / (_domain[0] - _domain[1]);
    }

    scale.invert = function (value:number) {
        return (value - _n) / _m;
    }

    scale.domain = function (domain?: any): any {
        if (arguments.length) {
            _domain = arguments[0].slice();
            scale.rescale();
            return scale;
        }
        return _domain;
    }

    scale.range = function (range?: any): any {
        if (arguments.length) {
            _range = arguments[0].slice();
            scale.rescale();
            return scale;
        }
        return _range;
    }

    // Statics
    scale.nice = function () {
        // do nothing
    }

    return scale;

};