javaScript基础--函数中this的指向问题

关键：当前函数的this是在函数被调用执行时才确定的。

注意：在非严格模式中，当this只向undefined时，它会自动只想全局对象。

function fn() {
    'use strict'
    console.log(this)
}

fn() // fn是调用者，独立调用，this为undefined
window.fn() // fn是调用者，被window所拥有，this为window对象

例1:

var a = 10
var obj = {
    a: 40
}
function fn() {
    console.log('fn this:', this)
    function foo() {
        console.log(this.a)
    }
    foo()
}
fn.call(obj)
fn()

非严格模式下：

fn this: Object: { a: 40 }
20

严格模式下：

fn this: Window {}
20

例2:

'use strict'
var a = 20
function foo() {
    var a = 1
    var obj = {
        a: 10,
        c: this.a + 20
    }
    return obj.c
}
console.log(window.foo()) // 40
console.log(foo()) // 报错 TypeError  foo独立调用，严格模式下this为undefined，所以a找不到

例3:

        var a = 20
        var foo = {
            a: 10,
            getA: function () {
                return this.a
            }
        }
        console.log(foo.getA()) // 10  被foo对象调用
        var test = foo.getA
        console.log(test()) // 20  test是调用者，与方法foo.getA的引用指向同一个函数

注意调用者的独立调用与被某个对象所调用的区别。

例4:

        function foo() {
            console.log(this.a)
        }
        function active(fn) {
            fn()
        }
        var a = 20
        var obj = {
            a: 10,
            getA: foo,
            active
        }
        active(obj.getA) // 20
        obj.active(obj.getA) // 20

第一个输出：active为执行传入的函数，obj.getA指向foo函数，故执行foo函数，此时foo的this为window，故输出 20。

第二个输出：ob j.active指向全局的active函数，传入的是obj.getA指向的foo函数，故输出还是20。

例5:

        var n = 'window'
        var object = {
            n: 'object',
            getN: function() {
                return function() {
                    return this.n
                }
            }
        }
        console.log(object.getN()())

执行object.getN()返回的是 function(){return this.n}函数，object.getN()()执行的就是 function(){return this.n} 函数，虽然外层是object调用，但是第一个return返回的函数是独立的，所以此时this指向undefined，但是此时非严格模式。。。。。。所以结果是  'window'。