javascript 是否有等价于 php 魔术类 __call [英] does javascript have an equivalent to the php magic class __call

问题描述

我想知道我能不能做:

var o={

   __call : function(methodname,arguments){
      alert(methodname);
   }

};

o.hello();  <-alerts 'hello'

类似于php的魔术方法__call

similar to php's magic method __call

我本质上想做的是调用将存在但在第一次运行代码时未知的函数，我可以通过类似的东西来做到这一点

what i essentially want to do is call functions which will exist but are unknown when the code is first run, i could do so via something like

function fn(){
   var s='mod';
   var o=mod;
   var n=arguments.length;
   for(var i=0;i<n;i++){
      var name=arguments[i];
      s+='.'+name;
      if(!o[name])return ()=>s+' not found';
      o=o[name];
   }
   return o;
}

var mod={
   square:{
      area:r=>r*r
   }
};

var a=fn('square','area')(5);     console.log(a);
var a=fn('circle','area')(6);     console.log(a);

但我更愿意使用

var a=mod.square.area(5);         console.log(a);
var a=mod.circle.area(6);         console.log(a);

推荐答案

它的粗糙和准备，但这里有一些有用的东西

its rough and ready, but here is something that sort of works

var mod=newproxy();
    
    
mod.callme.first$('hello','world');         //?  mod.callme.first.fn('hello','world');
    
mod.difcontext.hello='world';               //?  mod.difcontext.hello.prop='world';
    
mod.difcontext.start=['hello','world'];     
    
mod.difcontext.cat_;                        //?  mod.difcontext.cat.prop;
    
   
function newproxy(main){
          
    main=main||{};
    return proxy(main);
          
    function getter(target,name,receiver,lname){
    
        lname+=lname?'.'+name:name;
        var c=name[name.length-1];
        if(c==='$'){
            lname=lname.slice(0,-1);
            return function(){
                console.log('fn : ',lname,arguments);
            };
        }
        if(c==='_'){
            lname=lname.slice(0,-1);
            console.log('rd : ',lname);
            return;
        }
        return proxy(target,lname);
          
    }//getter
          
    function setter(obj,prop,newval,lname){
          
        lname+=lname?'.'+prop:prop;
        console.log('wt : ',lname,newval);
                
          
    }//setter
          
    function proxy(target,lname){
          
      lname=lname||'';
      var p=new Proxy(target,{
        get:(target,name,receiver)=>{return getter(target,name,receiver,lname);},
        set:(obj,prop,newval)=>{return setter(obj,prop,newval,lname);}
      });
                
      return p;
          
    }//proxy
          
}//newproxy
    

使用命名约定

$ 表示结束函数，(可能以 .fn 结束)

$ denotes an ending function, ( could of ended with .fn )

_ 表示读取变量，(可能以 .prop 结尾)

_ denotes reading variable, ( could of ended with .prop )

setter 可以用来调用一个函数，但它不是常规的

the setter could be used to invoke a function, but its not conventional

暂时我决定去

mod('difcontext.callme.first',['hello','world'],callback);

如果 getter 本质上知道它们是如何被调用的......

if the getters intrinsically had some knowledge of how they were being invoked ...

var mod=new Proxy({},{
      get:(target,name,receiver)=>{return function(){alert(name)}}
});
          
mod.hello();

有人提到了另一个问题，我在那里发布了一个更完整的解决方案:

I was referred to another question, i posted a more complete solution there :

是否有相当于属性的 noSuchMethod 特性，或者在 JS 中实现它的方法?

Is there an equivalent of the noSuchMethod feature for properties, or a way to implement it in JS?

这篇关于javascript 是否有等价于 php 魔术类 __call的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！