在typescript中可以做一个这样的模块吗？

Question

我想做一个可以这样调用的函数模块类。

const myvar = MyModule('a parameter').methodA().methodB().methodC();

//but also this should work

const myvar = MyModule('a parameter').methodC().methodA();

换句话说，做一个静态模块 可以接受不同数量的 "回调"，以任何可能的顺序。

我不想做一个类的实例，我希望每个方法都能返回一个字符串。

这可能吗？

EDIT

说得更清楚一些。我想用不同的方法来处理一个字符串作为输入。每个方法以一种方式处理字符串，并将结果返回给下一个方法。如果没有附加方法，它将返回字符串。

也许我的要求是不可能的。但是，也许存在着类似结构和相同结果的东西。

Answer 1

这是有可能的，但没有静态类命名为 MyModule，您需要添加到 String 创制新方法

declare interface String {
  methodA(): string;
  methodB(): string;
}

String.prototype.methodA = function(this: string) {
  return this.toLowerCase() + 'Lower';
}

String.prototype.methodB = function(this: string) {
  return this.toUpperCase() + 'Upper';
}

console.log('hello'.methodA().methodB(), 'hello2'.methodB().methodA().methodB());

输出。

HELLOLOWERUpper HELLO2UPPERLOWERUpper

但我不确定是否如你所料？

Answer 2

在这里，我得到了一个更多的解决方案，这是最接近预期的结果。

function MyModule(str: string) {
  return {
    str,
    methodA() {
      this.str = this.str.toUpperCase() + '1';
      return this;
    },
    methodB() {
      this.str = this.str.toLowerCase() + '2';
      return this;
    },
    methodC() {
      this.str = str.substr(0, 4);
      return this;
    },
    toString() {
      return this.str;
    },
    valueOf() {
      return this.str;
    }
  }
}

const myvar = MyModule('a parameter').methodA().methodB().methodC();
const myvar2 = MyModule('a parameter2').methodB().methodA();
console.log(`myvar: ${myvar}`);
console.log(`myvar2: ${myvar2}`);

输出。

myvar: a pa
myvar2: A PARAMETER221

但有一个问题，如果你 console.log(myvar) 那么你将看到的不是字符串，而是对象。为了达到你的目标，你需要用字符串连接这个变量，或者直接调用 .toString() 方法。

> console.log(myvar);
{
  str: 'a pa',
  methodA: [Function: methodA],
  methodB: [Function: methodB],
  methodC: [Function: methodC],
  toString: [Function: toString],
  valueOf: [Function: valueOf]
}

> console.log(myvar + myvar2);
a paA PARAMETER221

> console.log(myvar.toString());
a pa

> console.log('' + myvar);
a pa

> console.log(`${myvar}`);
a pa

Answer 3

这是我目前的解决方案。

export default class sanitize {

    private _var:any = '';

    private static _instance:sanitize;

    private constructor(){}

    private static _g(){
        return this._instance || (this._instance = new this());
    }
    public static return(){
        const ret = this._g()._var;
        this._g()._var = '';
        return ret;
    }
    private static return_class(){
        return this;
    }
    private static check_string(){
        if(typeof this._g()._var != 'string')
            this.string(this._g()._var);
    }
    public static string(variable:any){
        if(typeof variable.toString != undefined)
            this._g()._var = variable.toString();
        else
            this._g()._var = '';
        return this.return_class();
    }
    public static alphanum(){
        this.check_string();
        this._g()._var = this._g()._var.replace(/[^\w\s]/gi, '');
        return this.return_class();
    }
    public static tolow(){
        this.check_string();
        this._g()._var = this._g()._var.toLowerCase();
        return this.return_class();
    }
    public static toup(){
        this.check_string();
        this._g()._var = this._g()._var.toUpperCase();
        return this.return_class();
    }
    public static subs(start:number, end:number){
        this.check_string();
        this._g()._var = this._g()._var.substring(start, end);
        return this.return_class();
    }
}

// And then I call

const san_str = sanitize.string('could be a number').alphanum().tolow().return();