javascript如何通过返回要执行的方法来简化此代码？

我正在玩JS，有以下代码片段

var Dog = function(name) {
    this.name = name
}

Dog.prototype= {
    'bark': function() {
        alert(this.name + ' is barking');
    },
    'run': function() {
        alert(this.name + ' is running');
    }
}

var dogs = [new Dog('first'), new Dog('second'), new Dog('third')];


function invokeOnDog(what) {
    if(what === 'bark') {
        for(var i=0; i<dogs.length; i++) {
            dogs[i].bark();
        }
    }
    if(what === 'run') {
        for(var i=0; i<dogs.length; i++) {
            dogs[i].run();
        }
    }
}

我想做的是简化这个invokeOnDog函数，因为它会重复相同的模板两次。我正在考虑以某种方式返回应该在对象上调用的方法，但不知道如何执行

你能帮我吗

编辑：

感谢您的快速回复。如果调用的对象与要调用的方法具有相同的名称，则它们是ok的。但如果这两者之间没有匹配呢

invokeOnDog'aggressive'应该调用bark方法，invokeOnDog'scared'应该调用run

    function invokeOnDog(what) {
        for(var i=0; i<dogs.length; i++) {
          dogs[i][what]()
        }            
    }

---

试试这个，我认为它应该可以工作

您可以通过正常的属性查找访问该方法

function invokeOnDog(what) {

    if(what === 'bark' || what === 'run') {
        for(var i=0; i<dogs.length; i++) {
            dogs[i][what]();
        }
    }
}

使用访问包含函数的属性：

function invokeOnDog(what) {
    for (var i=0; i<dogs.length; i++)
        dogs[i][what]();
}

---

也许您想添加一个对dogs上方法存在性的检查，您可以使用what-in-dogs[i]或typeof-dogs[i][what]==函数进行检查。

在这种情况下，您可以从字符串中访问对象属性“bark”和“run”方法，如果不是

object.property

你用

object['property']

如果变量中有属性，则可以

var thing = 'property';
object[thing];

由于您有一个具有要调用的方法名称的变量，因此可以使用以下方法调用该方法：

dogs[i][what]();

所以它将是这样的：

function invokeOnDog(what) {
    if (what === 'bark' || what === 'run') {
        for(var i=0; i<dogs.length; i++) {
            dogs[i][what]();
        }
    }
}

更新：

如果变量与要调用的方法没有关系，则可以使用映射来设置关系：

function invokeOnDog(position) {
    var methods = {
        'agressive': 'bark',
        'defensive': 'run'
    };
    var method = methods[position];

    if (method)
        for(var i=0; i<dogs.length; i++) {
            dogs[i][method]();
        }
    }
}

这是最简单的代码，但我建议您检查position value是否是方法上的键，而不是继承的方法：

function invokeOnDog(position) {
    var methods = {
        'agressive': 'bark',
        'defensive': 'run'
    };

    if (mehtods.hasOwnProperty(position) {
        var method = methods[position];

        for(var i=0; i<dogs.length; i++) {
            dogs[i][method]();
        }
    }
}

---

否则，invokeOnDog'toString'将访问作为函数的方法['toString'。

在调用之前，还应检查属性是否存在：

function invokeOnDog(what) {
  if (Dog.prototype.hasOwnProperty(what)) {
    for (i = 0, len = dogs.length; i < len; i++) {
      dogs[i][what]();
    }
  }
}

---

Javascript数组语法也可用于访问对象的字段。所以狗吠可以用狗吠代替

像这样

function invokeOnDog(a) {
if (a === "bark") for (var b = 0; dogs.length > b; b++) dogs[b].bark();
if (a === "run") for (var b = 0; dogs.length > b; b++) dogs[b].run()
}
var Dog = function (a) {
this.name = a
};
Dog.prototype = {
bark: function () {
    alert(this.name + " is barking")
},
run: function () {
    alert(this.name + " is running")
}
};
var dogs = [new Dog("first"), new Dog("second"), new Dog("third")]

---

谢谢，我已经编辑了这个问题，并添加了一个案例。你应该看看这个案例。

function invokeOnDog(a) {
if (a === "bark") for (var b = 0; dogs.length > b; b++) dogs[b].bark();
if (a === "run") for (var b = 0; dogs.length > b; b++) dogs[b].run()
}
var Dog = function (a) {
this.name = a
};
Dog.prototype = {
bark: function () {
    alert(this.name + " is barking")
},
run: function () {
    alert(this.name + " is running")
}
};
var dogs = [new Dog("first"), new Dog("second"), new Dog("third")]