Question

我有一个这样的示例对象：

var shooter = {fire : function(){shootRightHandGun("shotgun");}}

然而，说射手找到了一把新枪，我们想要设置射手的射击功能：

{fire : function(){shootRightHandGun("shotgun"); shootLeftHandGun("handgun");}}

实现这一目标的最佳/最快方法是什么？辅助函数，对象中的函数数组，任何东西。我完全乐于接受建议。

Answer 1

你不应该为此替换功能，而是单独跟踪这些项目，从长远来看它可能对你有帮助。
您可能需要在代码的不同位置引用射击者持有的当前项目，进行各种检查和验证不要只是替换这样的函数。

var shooter = {
    leftGun: null,
    rightGun: "shotgun",

    fire: function() {
        if(this.rightGun != null) {
            shootRightHandGun(this.rightGun);
        }
        if(this.leftGun != null) {
            shootLeftHandGun(this.leftGun);
        }
    }
}

shooter.leftGun = "handgun";

稍后您可以使用适当的setter和getter轻松扩展代码，轻松添加一些额外的检查，以便：

getRightGun: function() { return this.rightGun; }
setRightGun: function(newRightGun) {
    if(isProperGun(newRightGun)) {              // some kind of a check
        this.rightGun = newRightGun;
    }
}

Answer 2

追加

var temp = shooter.fire;
shooter.fire = (function(t){
    return function(){
    t();
    shootLeftHandGun("handgun");
  }
})(temp);

编辑

shooter.fire = function(){shootLeftHandGun("handgun");};

小提琴：dbms_crypto

Answer 3

从技术上讲，您可以通过.toString()方法获取函数的源代码来编辑函数，然后使用regexp等对它进行字符串操作。但它会非常非常混乱，我不推荐它。

相反，为对象提供更多结构。首先将右手和左手武器分开：

var shooter = {
    rightHand : function () {},
    leftHand : function () {},
    fire : function () {}
}

现在让.fire()方法射击（或使用）所有武器：

var shooter = {
    rightHandWeapon : function () {},
    leftHandWeapon : function () {},
    fire : function () {
        this.rightHandWeapon();
        this.leftHandWeapon();
    }
}

现在，上面的代码什么也没做（因为两个函数什么都不做），这意味着上面的代码是针对非武装射手。

现在你可以将武器作为功能来实现：

function shotgun () {
    /* code to fire shotgun */
}

function handgun () {
    /* code to fire handgun */
}

要完成，我们也可以定义以下功能：

function unarmed () {};

现在你可以通过给他武器来武装射手：

// Armed with shotgun
shooter.rightHandWeapon = shotgun;
shooter.fire();

// Armed with shotgun and handgun:
shooter.rightHandWeapon = shotgun;
shooter.leftHandWeapon = handgun;
shooter.fire();

// Armed with TWO shotguns:
shooter.rightHandWeapon = shotgun;
shooter.leftHandWeapon = shotgun;
shooter.fire();

// Disarm the shooter:
shooter.rightHandWeapon = unarmed;
shooter.leftHandWeapon = unarmed;
shooter.fire(); // does nothing

Answer 4

如果用户可以找到更好的枪支，那么这样做的好方法是使用Gun类的继承。

es6中的示例，但您可以使用原型在es5中轻松完成此操作：

class SimpleGun {

    fire: function() {
       shootLeftHandGun("handgun");
    }
}


class BetterGun extends SimpleGun {
    fire: function() {
        super.fire();
        shootRightHandGun("handgun");
    }
}

因此，当用户找到另一支枪时，只需执行以下操作：

user.setGun(new BetterGun())

Answer 5

只要您的对象不是函数构造函数并且只是这样的简单对象，您可以直接向其添加所需的任何内容（属性，方法）：

shooter.shootLeftHandGun  = fucntion() {// Your code here. }

但是如果你的射手是用函数构造函数创建的（不是你的情况），你可以通过对象的原型轻松完成。

shooter.prototype.shootLeftHandGun = function() {// Your code here.}

而不是简单地动态创建对象，请尝试使用：]

function shooter() {
   this.shootRightHandGun = function() {
       // Code
   }
   this.name = "default name"
}

var newShooter = new shooter();
newShooter.prototype.shootLeftHandGun = function() { // Your new stuff.}

Answer 6

这是另一种选择：

var shooter = {
    guns:[{side:'right',type:'shootgun'}],
    fire : function(){
        for(var i = 0; i < this.guns.length; i++){
          this.shoot(this.guns[i]);
        }
    },
    gainGun : function(side, type){
        this.guns.push({side:side, type:type})
    },
    shoot:function(gun){
        console.log(gun)
    }
  }

Answer 7

看起来每个人都在这里堆积，这很酷。这是我的尝试。如果手中已装有枪，则该手被占用并且用户被告知它。我还添加了一个fireAllGuns函数来实现它的乐趣。

var shooter = {
  guns: {},
  fire: function(hand) {
    if (this.guns[hand]) {
      console.log("Firing " + this.guns[hand] + " from " + hand + " hand!");
    } else {
      console.log("There is no gun in that hand!")
    }
  },
  fireAllGuns: function() {
    for (var key in this.guns) {
      if (this.guns.hasOwnProperty(key)) {
        console.log("Firing " + this.guns[key] + " from " + key + " hand!");    
      }
    }
  },
  equipGun: function(hand, gun_name) {
    if (!this.guns[hand]) {
      this.guns[hand] = gun_name;
      console.log("Equipped " + gun_name + " in " + hand + " hand");
    } else {
      console.log("That hand is already occupied!")
    }
  }
};

shooter.fire("left");
// There is no gun in that hand!

shooter.equipGun("left", "pistol");
// Equipped pistol in left hand

shooter.fire("left");
// Firing pistol from left hand!

shooter.fire("right");
// There is no gun in that hand!

shooter.equipGun("right", "bazooka");
// Equipped bazooka in right hand 

shooter.fire("right");
// Firing bazooka from right hand!

shooter.fireAllGuns();
// Firing pistol from left hand!
// Firing bazooka from right hand!

什么是在对象中追加或编辑函数的最快方法？

7 个答案: