我想这更多是一个好奇心问题,如果它可以实际在打字稿中实现,那就太好了。
基本上我有一个类和其中的两个方法,如下所示:
这可能吗?
class MyClass{
private cleanup(str:String):String{
//clean up the string
return str; //return sanitized string
}
//I want to do this
insertString(this.cleanup(text_1:String), this.cleanup(text_2:String)){
console.log(text_1 + text_2);
}
}
而不是这个?
class MyClass{
private cleanup(str:String):String{
//clean up the string
return str; //return sanitized string
}
//might get to long if I have to cleanup to many strings
insertString(text_1:String, text_2:String){
text_1 = this.cleanup(text_1)
text_2 = this.cleanup(text_2)
console.log(text_1 + text_2);
}
}
您要实现的实际上不是从另一个方法签名中调用一个方法。更多有关处理参数列表的信息。
arguments
骇客您可以修改提供的arguments
数组,并且相应的命名参数也将更改。
insertString(text_1:String, text_2:String) {
// here text_1 and text_2 are not cleaned up yet
for (var i = 0; i < arguments.length; i++) {
arguments[i] = this.cleanup(arguments[i])
}
// text_1 and text_2 are now cleaned up
}
但是,这种方法有点骇人听闻,您可以选择#2:
我们声明了两个修饰符:一个名为的参数修饰符cleanup
:
function cleanup(target: Object, propertyKey: string | symbol, parameterIndex: number) {
let cleanupParams: number[] = Reflect.getOwnMetadata("MyClass:cleanup", target, propertyKey) || [];
cleanupParams.push(parameterIndex);
Reflect.defineMetadata("MyClass:cleanup", cleanupParams, target, propertyKey);
}
一个名为方法的装饰器CleanupMethod
(实际上是一个装饰器工厂):
function CleanupMethod(func){
return function (target: any, propertyName: string, descriptor: TypedPropertyDescriptor<Function>) {
let method = descriptor.value;
descriptor.value = function () {
let requiredParameters: number[] = Reflect.getOwnMetadata("MyClass:cleanup", target, propertyName);
if (requiredParameters) {
for (let parameterIndex of requiredParameters) {
arguments[parameterIndex] = func(arguments[parameterIndex]);
}
}
return method.apply(this, arguments);
}
}
}
在装饰器中,我们保存一个清单,其中应在函数enter中清除哪些参数,然后在每次调用时清除它们。
用法:
class MyClass{
private cleanup(str:string):string{
//clean up the string
return '[sanitized ' + str + ']'; //return sanitized string
}
@CleanupMethod(MyClass.prototype.cleanup)
insertString(text_1:string, @cleanup text_2:string){
console.log(text_1 + text_2);
}
@CleanupMethod(MyClass.prototype.cleanup)
insertNumber(n1: number, n2: number, @cleanup n3: number, n4: number, n5: number){
console.log(`${n1} + ${n2} + ${n3} + ${n4} + ${n5}`)
}
}
var m = new MyClass();
m.insertString('a', 'b') // outputs `a[sanitized b]`
m.insertNumber(10,20,30,40,50) // outputs `10 + 20 + [sanitized 30] + 40 + 50`
清除功能作为参数传递给CleanupMethod
工厂。这样,您可以拥有不同的清理功能,例如:
@CleanupMethod(cleanupString)
insertString( @cleanup str1: string, @cleanup str2: string2 ){
/*...*/
}
@CleanupMethod(cleanupNumber)
insertNumber( @cleanup n1: number ){
/*...*/
}
如果需要,可以重写装饰器代码并将清除函数移至参数装饰器,但这将增加所需的代码量:
@CleanupMethod
insertString( @cleanup(cleanupString) str1: string, @cleanup(cleanupNumber) n1: number ){
/*...*/
}
本文收集自互联网,转载请注明来源。
如有侵权,请联系[email protected] 删除。
我来说两句