js中为什么以下程序不是返回1，而是返回2？

Question

javascriptjs

Answer 1

无论是从数组的长度来看 还是从调用getComponentCount的对象来看（this.a）都应该返回2  怎么会 是1呢数组中一开始就push了一个对象，接下来application.registerComponent(new OtherComponent());又加了一个 自然是2

Answer 2

你先搞明白this.a是哪个a先吧，这跟push压根就没关系<script>
(function(){
var a = 1;
var application=function(){
return{
a:8,
getComponentCount:function(){
return this.a;
},
getA:function(){
return a;
}
}
};
var app = new application();
alert(app.getComponentCount());
alert(app.getA());
})();
</script>

Answer 3

若把 a : 2,去掉为什么不会显示1，而是显示undefined？为什么获取不了最外部变量a = 1？

Answer 4

这是object Object  not  object Function

Answer 5

应该是 return a;（此时才会按照作用域链逐层往上找） 而不是 return this.a 你应该明白this的当前指向，this 指向调用函数的当前对象 你把当前对象的a:2去掉了，那么就相当于访问了一个对象中 不存在的属性，自然返回undefined若把 a : 2,去掉为什么不会显示1，而是显示undefined？为什么获取不了最外部变量a = 1？

Answer 6

(function() {
    function BaseComponent() {
    }
    function OtherComponent() {
    }
     
    var a = 1;
    var application = function() {
        var components = new Array();
        components.push(new BaseComponent());
        return {
            a : 2,
            getComponentCount: function() {
                /*alert(this.a);
                return components.length;*/
                return this.a;
            },
            registerComponent: function(component) {
                if (typeof component == 'object') {
                    components.push(component);
                }
            }
        };
    }();
     
    application.registerComponent(new OtherComponent());
    alert(application.getComponentCount());application为你返回的json对象，this指向那个json对象，this.a就是json对象的属性a，那不是2是什么，要返var a=1，直接return a，不要加this而且你的代码有问题吧。。报错了，最后少了})();

Answer 7

若把 a : 2,去掉为什么不会显示1，而是显示undefined？为什么获取不了最外部变量a = 1？但以下这个例子的this指向始终都是window：var name = 'The Window';
var object = {
    name: 'My object',
    getNameFunc: function() {
        return function() {
             return this.name;
        };
    }
};
alert(object.getNameFunc()());
输出：The Window 而不是 My object。这两段代码都差不多的，为什么上面的代码this.a 不是输出 1？除非在return this.a之前再定义一个var that = this;后面改成return that.a这样子才输出 2不是吗？

Answer 8

匿名函数的this对象通常指向window

Answer 9

var a = 1;
var obj = {
a:2,
fn1:function(){
console.log(this.a);  //2
~function(){
console.log(this.a);  //1
}()
}
}
obj.fn1();

Answer 10

若把 a : 2,去掉为什么不会显示1，而是显示undefined？为什么获取不了最外部变量a = 1？但以下这个例子的this指向始终都是window：var name = 'The Window';
var object = {
    name: 'My object',
    getNameFunc: function() {
        return function() {
             return this.name;
        };
    }
};
alert(object.getNameFunc()());
输出：The Window 而不是 My object。这两段代码都差不多的，为什么上面的代码this.a 不是输出 1？除非在return this.a之前再定义一个var that = this;后面改成return that.a这样子才输出 2不是吗？
(1)
6楼是正解~~
“这两段代码都差不多的...” 程序里面，差一点就会是完全两个概念，差不多这个词以后还是杜绝的号~~(2)
js里函数中的this指向取决于调用该函数的对象。把你的第二个例子中getNameFunc函数修改如下：    getNameFunc: function() {
        var x='hello';
        alert(this.a)
        return function() {
             alert(x);
             alert(this.name)
        };
    };
    object.getNameFunc();
    object.getNameFunc()();
“object.getNameFunc();”：函数getNameFunc是作为object的方法执行，即被object调用，所以this指向的是object。
“object.getNameFunc()()”：因为object.getNameFunc()最后返回的是个函数，所以--->
object.getNameFunc()() 等于 （function(){alert(this.name)}）();，显然“function(){alert（this.name)}”这个函数并不是作为某个显示声明的对象的方法去执行的(obj.func()的形式)，而是作为全局函数执行的，即调用它的对象为window,所以会弹出“the window”。嵌套函数中，尤其是闭包（例子中getNameFunc函数的执行就形成了闭包），外部函数的变量会传递到内部函数（所以alert(x)弹出的是外层函数的x 即字符串hello），但是this是不会传递的，this只和包含this的函数的执行有关。

Answer 11

var name = 'The Window';
var object = {
    name: 'My object',
    getNameFunc: function() {
        return function() {
             return this.name;
        };
    }
};
alert(object.getNameFunc()());this是只有在执行时才能确认只带含义的关键字.
将上面简写形式的代码重写为完整形式会更好理解.

Answer 12

设置一个临时变量:
var first = object.getNameFunc();
也就是:
var first = function(){
return this.name;
};
所以原来代码等同于:
alert(first());
补齐前面省略的一个this:
alert(this.first());再令
var second = first();
即:
var second = this.first();
所以first()函数体的this指向Global对象,在浏览器中是window,window.name="The Window"

Answer 13

function A(){
var B = function(){
alert(this);
};
B();
return B;
}
判断this代表那个对象,关键在于,A属于window成员函数,但A的返回值不一定是window的成员函数,要看哪个对象接收B这个返回值.
谁接收B并调用,B就属于谁.
直接在A函数体中调用B(),那么B和A的this是一样的,如果A是window的,那么B也属于window,即window.B().
如果用
anObject.anFunction = A();
那么显然anObject.anFunction()得到的返回值B这个函数对象被"挂载"到了anObject中,this指向anObject.

Answer 14

各位的意思是不是说：var name = 'The Window';
var object = {
name: 'My object',
/*getNameFunc: function() {
return function() {
 return this.name;
};
}*/
getNameFunc: function() {
var x='hello';
alert('this.a:'+this.name);

return function() {
 alert('x:'+this.x);
 alert('this.name:'+this.name);
};
}
};
//alert(object.getNameFunc()()); // The Window
//object.getNameFunc();
function aa(){
var name = '55';
var b = object.getNameFunc()();
}
aa();
这例子来说的话：getNameFunc: function()这个里面的this就是json里的name: 'My Object'，没有this就表示全局变量name = 'The Window'；而return function()里的变量是否有this都表示全局变量name = 'The Window'？还有，若是这样的话为什么我加了
function aa(){
var name = '55';
var b = object.getNameFunc()();
}
aa();
这个函数（调用getNameFunc()()的语句放在其中）后，return function()里的this.name还是表示name = 'The Window'？

Answer 15

这例子来说的话：getNameFunc: function()这个里面的this就是json里的name: 'My Object'，//不能这么说.这个function()函数对象所指向的内存空间是不属于任何对象的,getNameFunc这个属性只是获得这个指针而已,所以随便哪一个变量都可以指向function(),你可以用object.getNameFunc来获取这个function()的内存空间,也可以用var outerFunc = function(){...}来获取.但是显然getNameFunc和outer分别属于两个对象(object和window),所以这时有两个变量(属性)指向function()所代表的的内存空间,而this只有在函数调用时才可最终确定(调用函数时,执行环境才会将this的值赋给函数),在函数创建的时候是没法获取this指代的对象的.getNameFunc: function()这句话只是为属性赋值(赋值为一个函数对象),但是函数还没有执行,所以this还没赋值.没有this就表示全局变量name = 'The Window'；//没有this要看函数的执行环境,不一定是全局,但在这里就是全局.如果你在执行另一个函数体里面创建object,而这个函数体里有name变量,那么不加this的name就是这另一个函数的局部变量.
var name = "Window";
function(){
    var name = "Puck";
    var object = {
        name : "Jugg",                //在创建好整个object对象之前, 这个name是不可见的.因为字面量形式创建对象时,只有在执行完最后一句之后才返回这个对象.
        getName : function(){
            alert(name);                //"Puck",根据闭包
        }
    }
}();而return function()里的变量是否有this都表示全局变量name = 'The Window'？//根据上述,return function()不等于调用这个function(),调用时才能确定this.要看return给谁,也就是function()被"挂载"到那个对象的属性之下,并且被调用才能确定this.
A.fun = function(){return function(){this.name;...}}(); //函数被赋值到A.fun属性,还是那句话,this在执行前依旧无法确定
A.fun(); //this -> A
B.fun = function(){return function(){this.name;...}}();
B.fun(); //this -> B还有，若是这样的话为什么我加了
function aa(){
var name = '55';
var b = object.getNameFunc()();
}
aa();
aa属于window即 -> window.aa();
里面的b当然也属于window -> window.bb();
object.getNameFunc()();也就是:(object.getNameFunc())();
object.getNameFunc()返回function(),在没有变量接收的情况下属于当前执行环境的对象,相当于有个临时变量
var temp = object.getNameFunc();
然后temp(); this -> wiindow