Javascript 如何在仍然返回值的情况下断开自定义方法链？

我对搜索变量执行替换，将已知组转换为组名

我觉得，在每一步中，我都可以进行正则表达式匹配，查看搜索查询中是否还有两个或更多的组成员，如果没有，则中止链。这是我经常使用的函数，如果没有匹配项，它负责跳出该过程

我的实际替换链是15长，如果我能在第一次或第二次跳出，这似乎是合适的

所以，我想我应该写这样的东西

String.prototype.abortreplace=函数（m，r）{
var-toreturn；
if（此.match（/\b\w\b/g）.length>0）{
toreturn=此。替换（m，r）；
}否则{
返回；
}
回归回归；
}
tx=“a、b、c、d、e、f、g、h、i、j、k、l、m、n、o、p”；
tx2=tx.abortreplace（/a，b，c/g，“前三个字母”）。abortreplace（/d，e，f/g，“后三个字母”）。abortreplace（/g，h，i/g，“第三个字母”）。abortreplace（/j，k，l/g，“第四个三个字母”）。abortreplace（/m，n，o/g，“第五个三个字母”）。abortreplace（/p，q，r/g，“第六个三个字母”）；
警报（tx2）而不是将自己的方法放在
字符串
原型（ugh）上，您可以提出自己的数据结构来做您想要的事情

下面的想法是，有一种类型的对象可以执行您想要的处理并返回可链接的对象，当时间到来时，它可以使用相同的接口返回另一种类型，从而缩短后续链接调用：


var replacer=（函数（）{
功能固定置换器（str）{
变量r={
abortreplace:函数（）{
//这个abortreplace只返回调用它的对象
返回r；
},
toString:function（）{
返回str；
}
};
返回r；
}
函数替换器（str）{
返回{
中止位置：函数（m，r）{
返回（str.match（/\b\w\b/g）| |[]）。长度>2
？替换件（str.replace（m，r））
：固定式置换器（str）；
},
toString:function（）{
返回str；
}
};
}
返回替换器；
})();
tx=“a、b、c、d、e、f、g、h、i、j、k、l、m、n、o、p”；
tx2=更换件（tx）
.abortreplace（/a、b、c/g，“前三个字母”）
.abortreplace（/d，e，f/g，“第二个三个字母”）
.abortreplace（/g，h，i/g，“第三个字母”）
.abortreplace（/j，k，l/g，“第四个三个字母”）
.abortreplace（/m，n，o/g，“第五个三个字母”）
.abortreplace（/p，q，r/g，“第六个三个字母”）
.toString（）；
控制台日志（tx2）而不是将自己的方法放在
字符串
原型（ugh）上，您可以提出自己的数据结构来做您想要的事情

下面的想法是，有一种类型的对象可以执行您想要的处理并返回可链接的对象，当时间到来时，它可以使用相同的接口返回另一种类型，从而缩短后续链接调用：


var replacer=（函数（）{
功能固定置换器（str）{
变量r={
abortreplace:函数（）{
//这个abortreplace只返回调用它的对象
返回r；
},
toString:function（）{
返回str；
}
};
返回r；
}
函数替换器（str）{
返回{
中止位置：函数（m，r）{
返回（str.match（/\b\w\b/g）| |[]）。长度>2
？替换件（str.replace（m，r））
：固定式置换器（str）；
},
toString:function（）{
返回str；
}
};
}
返回替换器；
})();
tx=“a、b、c、d、e、f、g、h、i、j、k、l、m、n、o、p”；
tx2=更换件（tx）
.abortreplace（/a、b、c/g，“前三个字母”）
.abortreplace（/d，e，f/g，“第二个三个字母”）
.abortreplace（/g，h，i/g，“第三个字母”）
.abortreplace（/j，k，l/g，“第四个三个字母”）
.abortreplace（/m，n，o/g，“第五个三个字母”）
.abortreplace（/p，q，r/g，“第六个三个字母”）
.toString（）；
控制台日志（tx2）而不是将自己的方法放在
字符串
原型（ugh）上，您可以提出自己的数据结构来做您想要的事情

下面的想法是，有一种类型的对象可以执行您想要的处理并返回可链接的对象，当时间到来时，它可以使用相同的接口返回另一种类型，从而缩短后续链接调用：


var replacer=（函数（）{
功能固定置换器（str）{
变量r={
abortreplace:函数（）{
//这个abortreplace只返回调用它的对象
返回r；
},
toString:function（）{
返回str；
}
};
返回r；
}
函数替换器（str）{
返回{
中止位置：函数（m，r）{
返回（str.match（/\b\w\b/g）| |[]）。长度>2
？替换件（str.replace（m，r））
：固定式置换器（str）；
},
toString:function（）{
返回str；
}
};
}
返回替换器；
})();
tx=“a、b、c、d、e、f、g、h、i、j、k、l、m、n、o、p”；
tx2=更换件（tx）
.abortreplace（/a、b、c/g，“前三个字母”）
.abortreplace（/d，e，f/g，“第二个三个字母”）
.abortreplace（/g，h，i/g，“第三个字母”）
.abortreplace（/j，k，l/g，“第四个三个字母”）
.abortreplace（/m，n，o/g，“第五个三个字母”）
.abortreplace（/p，q，r/g，“第六个三个字母”）
.toString（）；
控制台日志（tx2）而不是将自己的方法放在
字符串
原型（ugh）上，您可以提出自己的数据结构来做您想要的事情

下面的想法是，有一种类型的对象可以执行您想要的处理并返回可链接的对象，当时间到来时，它可以使用相同的接口返回另一种类型，从而缩短后续链接调用：


var replacer=（函数（）{
功能固定置换器（str）{
变量r={
abortreplace:函数（）{
//这个abortreplace只返回调用它的对象
返回r；
},