为什么应用程序在自定义javascript对象函数中的行为不符合预期

我试图理解apply和call方法是如何工作的，但是下面代码的结果完全把我弄糊涂了

var arr = new Array(100);
console.log.apply(console, arr);

这导致console.log（）被调用100次（并且输出未定义，因为arr的大小为100，并且其中没有值）

那么，为什么我不能生产类似的产品呢

var obj = {
     i:0

    };
    obj.x = function(){
     console.log("count: "+this.i);
     this.i++;
    }

    var arr = new Array(100);
    obj.x.apply(obj, arr);

---

我所期望的是打印出“count:0”…所有方式都是“count:99”，而它只是在生成“count:0”作为唯一输出时触发。显然，我不理解，请澄清

apply

所做的是获取一组参数，并使用这些参数调用相关函数

var obj = {
    i:0
};
obj.x = function(){
    for (var j = 0; j < arguments.length; j++) {
        console.log("count: "+this.i);
        this.i++;
    }
}

var arr = new Array(100);
obj.x.apply(obj, arr); // 0-99
obj.x("foo","bar","foobar"); // 100-102

例如：

function foo(a,b) {
    alert(a+b);
}
foo.apply(null, [1,2]); // alerts 3

这有意义吗

---

通常，当有疑问时，请参阅。

应用所做的是获取参数数组，并使用这些参数调用相关函数

var obj = {
    i:0
};
obj.x = function(){
    for (var j = 0; j < arguments.length; j++) {
        console.log("count: "+this.i);
        this.i++;
    }
}

var arr = new Array(100);
obj.x.apply(obj, arr); // 0-99
obj.x("foo","bar","foobar"); // 100-102

例如：

function foo(a,b) {
    alert(a+b);
}
foo.apply(null, [1,2]); // alerts 3

这有意义吗

---

一般来说，如有疑问，请查阅。

您误解了第一个片段

这将导致console.log（）被调用100次

否，它使用100个参数调用一次

console.log

。您的第二个代码段调用了一次带有100个参数的

obj.x

var obj = {
    i:0
};
obj.x = function(){
    for (var j = 0; j < arguments.length; j++) {
        console.log("count: "+this.i);
        this.i++;
    }
}

var arr = new Array(100);
obj.x.apply(obj, arr); // 0-99
obj.x("foo","bar","foobar"); // 100-102

要使第二个代码段以相同的方式执行，必须迭代参数

var obj = {
    i:0
};
obj.x = function(){
    for (var j = 0; j < arguments.length; j++) {
        console.log("count: "+this.i);
        this.i++;
    }
}

var arr = new Array(100);
obj.x.apply(obj, arr); // 0-99
obj.x("foo","bar","foobar"); // 100-102

var obj={
i:0
};
obj.x=函数（）{
对于（var j=0；j

您误解了第一个片段

这将导致console.log（）被调用100次

否，它使用100个参数调用一次

console.log

。您的第二个代码段调用了一次带有100个参数的

obj.x

var obj = {
    i:0
};
obj.x = function(){
    for (var j = 0; j < arguments.length; j++) {
        console.log("count: "+this.i);
        this.i++;
    }
}

var arr = new Array(100);
obj.x.apply(obj, arr); // 0-99
obj.x("foo","bar","foobar"); // 100-102

要使第二个代码段以相同的方式执行，必须迭代参数

var obj = {
    i:0
};
obj.x = function(){
    for (var j = 0; j < arguments.length; j++) {
        console.log("count: "+this.i);
        this.i++;
    }
}

var arr = new Array(100);
obj.x.apply(obj, arr); // 0-99
obj.x("foo","bar","foobar"); // 100-102

var obj={
i:0
};
obj.x=函数（）{
对于（var j=0；j

“这导致console.log（）被调用100次”不，它调用console.log一次，包含100个参数。您的第二个代码段调用了一次带有100个参数的

obj.x

。“这导致console.log（）被调用100次”否，它调用了一次带有100个参数的console.log。您的第二个代码段调用了一次带有100个参数的

obj.x

。是的，我知道，但是如果我在console.log上传递一个空数组，它仍会调用console.log 100次，但为什么它不为我的函数这样做呢？

console.log

接受任意数量的参数，并依次记录每个参数。在某些浏览器中，这是100个单独的日志。在其他情况下，它们会一个接一个地在线记录。观察到的一个函数（

console.log

）的行为几乎不足以确定完全不相关的函数（

function.apply

）的行为是的，我理解这一点，但如果我传递一个空数组以应用于console.log，它仍会调用console.log 100次，但为什么它不为我的函数执行此操作？

console.log

接受任意数量的参数，并依次记录每个参数。在某些浏览器中，这是100个单独的日志。在其他情况下，它们会一个接一个地在线记录。观察到的一个函数（

console.log

）的行为几乎不足以确定完全不相关的函数（

function.apply

）的行为