又是这个问题，怎么追加运行事件......

Question

<script>
var A = function ()
{
this.alert = function ()
{
alert('A');
}
}var B = function ()
{
this.alert = function ()
{
alert('B');
}
}
var A = new A();
var B = new B();A.alert();
</script>想执行A.alert(); 的时候后接着再执行B.alert();的代码
前提是A函数不能改动。要怎么写呢? 目前是这么一个情况，
是要做类似插件的功能，能给用户开发插件。
除了绑定的系统函数运行之外，也要让插件开发者的自定义函数执行。
前提是系统的函数都不能改动，也就上面的A函数不能改动。上一贴坛里一朋友提到用call但最后还是不成功。

Answer 1

<script>
Aspects = new Object();
Aspects.addBefore = function(obj, fname, before) {
    var oldFunc = obj[fname];
    obj[fname] = function() {
        return oldFunc.apply(this, before(arguments, oldFunc, this));
    };
};
Aspects.addAfter = function(obj, fname, after) {
    var oldFunc = obj[fname];
    obj[fname] = function() {
        return after(oldFunc.apply(this, arguments), arguments, oldFunc, this);
    };
};
Aspects.addAround = function(obj, fname, around) {
    var oldFunc = obj[fname];
    obj[fname] = function() {
        return around(arguments, oldFunc, this);
    };
};var A = function (){
    this.alert = function (){
        alert('A');
    }
}var B = function (){
    this.alert = function (){
        alert('B');
    }
}
var a = new A();
var b = new B();Aspects.addAfter(a,"alert",b.alert);//将b.alert方法动态增加给aa.alert();
</script>

Answer 2

厉害，感谢。是可以的。不过这样的形式的时候怎么写。
var A = function (){
        alert('A');
}
var B = function (){
        alert('B');
}
var a = new A();
var b = new B();把b加到a时面去。。我按你的思路去写，但不知为什么直接弹出来了。不是调用时才执行。<script>
var f = function ()
{
alert('f');
}
var c = function ()
{
alert('c');
} var E = function (object, NewObject)
{
var _object = object;
object = function ()
{
return NewObject(_object.call(this));
};
}
var f = new f();
var c = new c();
E(f,c);

// f();
</script>

Answer 3

回复6#：
你写到的new A()，就相当直接调用A方法，并非类和对象的那种关系。

Answer 4

楼主找找 js 继承写一个类，继承A

Answer 5

new A() 嗯? 哪应该怎么改下呢...。。 

Answer 6

<script>
var A = function ()
{
    this.alert = function()
    {
        alert('A');
    }
}var B = function ()
{
    this.alert = function()
    {
        alert('B');
    }
}function c(_this){
console.log(_this);
new B().alert();
_this.alert();  //指向A对象
}
c.call(new A().alert(),new A());
</script>

Answer 7

你console哪来啊。是要把B加到A里面去。最后执行A的时候才运行 A与B。

Answer 8

我表示震惊，话说那个console.log的含义么，，自己去查找吧，这样才会印象深刻

Answer 9

我在练习一个编码习惯，就是在编码中我一定要分清楚此时的this对象指的是什么，方便编程而已，上述例子，你可以不管this，这只是我的习惯

Answer 10

又学习了。console在firfox与chrome里可以输出调试
你例子我看得懂啊。
把c放到A里面运行，然后c里面_this又是指的是A对象
这样一来就会弹出A B A。但是说 最后把B加到A里面你没做到呢。

Answer 11

方法1var A=function()
{
    B.apply(this,arguments);
    this.alert = function ()
    {
        alert('A');
    }
}var B=function()
{
    this.alert = function ()
    {
        alert('B');
    }
}这种方法缺点是A函数把B函数里的同名方法覆盖了方法2var A=function()
{
    this.alert = function ()
    {
        alert('A');
    }
}var B=function()
{
    this.alert = function ()
    {
        alert('B');
    }
}
A.prototype=new B();new A().alert();
A.prototype.alert.apply();
方法3
var A=function()
{
    this.alert = function ()
    {
        alert('A');
    }
}var B=function()
{
    this.alert = function ()
    {
        alert('B');
    }
}
function c(){
  var a=new A();
   var b=new B();
  a.alert();
  b.alert();
}
var s=new c();

Answer 12

都没符合要求啊
方法一、并没把B的alert加到A的alert里面去，且改动了原函数了。
方法二、也没加到A里面去，A.prototype.alert.apply();这样有点打酱油的味道啊。。
直接A.prototype.alert();也不是一样么，最后调用的也不是原函数。方法三、没改动原函数这符合，两个都触发也符合，但这样一实例化就触发了，也不是执行原来的原函数才触发。你看四楼那个啊，原A函数没有改动，最后也是调A函数进行触发，同时B的也会执行了。
我用别的方法解决问题了，感觉这样也不太好，有些乱。

Answer 13

不必要那样复杂。<script>
Function.prototype.$Asynch = function ( Method ) {
    this ();
    Method ();
}var A = function ()
{
    this.alert = function ()
    {
        alert('A');
    }
}var B = function ()
{
    this.alert = function ()
    {
        alert('B');
    }
}var A = new A();
var B = new B();
A.alert.$Asynch( B.alert )
</script>

Answer 14

<script>
Function.prototype.$Asynch = function ( Method ) {
    this.constructor === Function && this ();
    ! Method || Method.constructor === Function && Method ();
}var A = function ()
{
    this.alert = function ()
    {
        alert('A');
    }
}var B = function ()
{
    this.alert = function ()
    {
        alert('B');
    }
}var A = new A();
var B = new B();
A.alert.$Asynch( B.alert )
</script>

Answer 15

最简单的
<script>
var A = function ()
{
    this.alert = function ()
    {
        alert('A');
    }
}var B = function ()
{
    this.alert = function ()
    {
        alert('B');
    }
}
A.prototype.Alert=function(){
this.alert();
B.alert();
}var A = new A();
var B = new B();A.Alert();
</script>

Answer 16

你这个也不是调原函数触发的，alert 与Alert还是有区别的啊。
看样子不能蛋疼你拉。

Answer 17

var A = function ()
{
    this.alert = function ()
    {
        alert('A');
    }
}
var B = function ()
{
    this.alert = function ()
    {
        alert('B');
    }
    
}

var AOP = {
after: function(target, method, additionMethod){
var oldMethod = target && target[method];
if(!oldMethod) return;
target[method] = function(){
oldMethod();
additionMethod();
}
},
before: function(target, method, additionMethod){
var oldMethod = target && target[method];
if(!oldMethod) return;
target[method] = function(){
additionMethod();
oldMethod();
}
}
}
var A = new A();
var B = new B();

AOP.after(A, 'alert', B.alert);
A.alert();