换个思路清楚Javascript中的this,的多种采纳情状

换个思路清楚Javascript中的this

2017/07/27 · JavaScript
· this

原稿出处: Leechikit   

在网上广大小说都对 Javascript 中的 this
做了详细的介绍,但大多是介绍种种绑定方式或调用格局下 this
的指向,于是自己想有一个集合的思绪来更好领会 this
指向,使大家更好判断,以下有局地内容不是常理,而是一种解题思路。

Javascript 中的
this,有时候让人迷惑,所以总括了一晃有关this指向的标题。

1. 大局代码中的this

      this在全局上下文中,它的值是大局对象自我(Global
Object),在浏览器中就是Window  Object,如下图示。

      澳门葡京 1

      看下边多少个例子:

//Global scope
//The implicit property of the global object 
var foo1 = “abc”;
console.log(this.foo1 == window.foo1); console.log(foo1); console.log(this.foo1); console.log(window.foo1);  //true abc abc abc
 
//The implicit property of the global object 
foo2 = “def”;  
console.log(this.foo2 == window.foo2); console.log(foo2); console.log(this.foo2); console.log(window.foo2);      //true def def def
 
//The explicit property of the global object 
this.foo3 = “gh”;  
console.log(this.foo3 == window.foo3); console.log(foo3); console.log(this.foo3); console.log(window.foo3); //true gh gh gh

 

js 基础

  1. var val = (1,2,4)
    val //4
  2. var obj = {}
    Object.defineProperty(obj, ‘x'{
    configurable:false,
    value:1
    })
    delete obj.x //false
    obj.x //1

3.in

window.x = "1"
"x" in window //true
  1. try {
    throw “test”;
    } catch (ex) {
    console.log(ex); // test
    } finally {
    console.log(‘finally’);
    }
  2. ‘use strict’
    严苛形式是一种极度的履行形式,
    它修复了部分语言上的欠缺,提供更强的荒谬检查,并进步安全性。
    不容许用with所有变量必须表明,
    赋值给为注解的变量报错,而不是隐式创立全局变量。
    eval中的代码无法创建eval所在功用域下的变量、函数。而是为eval单独创设一个成效域,并在eval重临时甩掉。
    函数中得万分对象arguments是静态副本,而不像非严加格局那样,修改arguments或涂改参数变量会相互影响。
    删除configurable=false的性质时报错,而不是忽视
    不准八进制字面量,如010 (八进制的8)
    eval, arguments变为关键字,不可作为变量名、函数名等
    相似函数调用时(不是目的的艺术调用,也不拔取apply/call/bind等修改this)this指向null,而不是全局对象。
    若拔取apply/call,当传入null或undefined时,this将本着null或undefined,而不是全局对象。
    打算修改不可写属性(writable=false),在不足扩张的对象上添加属性时报TypeError,而不是忽视。
    arguments.caller, arguments.callee被禁用

prototype //直接讲明的函数 拥有prototype这么些特性,而new
构造出来的函数不设有prototype这一个属性象。

function foo(){}                                function foo2(){}
undefined                                       undefined
foo.x = 1                                       foo2.prototype.x = 1
1                                               1
foo.y=2                                         foo2.prototype.y = 1
2                             VS                1
var test = new foo()                            var test2= new foo2()
undefined                                       undefined
test2                                           test2
foo {}                                          foo2 {x: 1, y: 1}
test.x                                          test2.x
undefined                                       1
  1. 目的创制

    var a ={} var b = Object.create({x:1})
    undefined undefined
    a.x =1 b.x
    1 1
    a.hasOwnProperty(‘x’) b.hasOwnProperty(‘x’)
    true false

  2. 对象属性删除

    var a = {}
    a.x = 1
    delete a.x`

    var globalVal = 1;
    delete globalVal; // false

    (function() {
    var localVal = 1;
    return delete localVal;
    }()); // false

    ohNo = 1;
    window.ohNo; // 1
    delete ohNo; // true

  3. 对象属性检测
    in hasOwnProperty propertyIsEnumerable

  4. 枚举类型

    var o = {x : 1, y : 2, z : 3};
    for (var key in o) {
    console.log(key); // x, y, z
    }

  5. getter setter
    var man = {
    name : ‘Bosn’,
    weibo : ‘@Bosn’,
    get age() {
    return new Date().getFullYear() – 1988;
    },
    set age(val) {
    console.log(‘Age can’t be set to ‘ + val);
    }
    }
    console.log(man.age); // 27
    man.age = 100; // Age can’t be set to 100
    console.log(man.age); // still 27
    var man = {
    weibo : ‘@Bosn’,
    $age : null,
    get age() {
    if (this.$age == undefined) {
    return new Date().getFullYear() – 1988;
    } else {
    return this.$age;
    }
    },
    set age(val) {
    val = +val;
    if (!isNaN(val) && val > 0 && val < 150) {
    this.$age = +val;
    } else {
    throw new Error(‘Incorrect val = ‘ + val);
    }
    }
    }

对象属性及的权柄设置

       var person = {};
       Object.defineProperty(person, 'name', {
       configurable : false, //配置
        writable : false,   //写
       enumerable : true, //枚举
       value : "Bosn Ma" //值
       });
       person.name; // Bosn Ma
   person.name = 1;
   person.name; // still Bosn Ma
   delete person.name; // false
        Object.defineProperties(person, {
    title : {value : 'fe', enumerable : true},
    corp : {value : 'BABA', enumerable : true},
    salary : {value : 50000, enumerable : true, writable : true}
});
Object.getOwnPropertyDescriptor(person, 'salary');
// Object {value: 50000, writable: true, enumerable: true, configurable: false}
Object.getOwnPropertyDescriptor(person, 'corp');
// Object {value: "BABA", writable: false, enumerable: true, configurable: false}`
  1. call apply
    1、方法定义
    call方法:
    语法:call([thisObj[,arg1[, arg2[,[,.argN]]]]])
    概念:调用一个对象的一个形式,以另一个目的替换当前目的。
    说明:

    call 方法能够用来代替另一个目的调用一个措施。call
    方法可将一个函数的目的上下文从起初的上下文改变为由 thisObj
    指定的新目标。
    如若没有提供 thisObj 参数,那么 Global 对象被看做 thisObj。

    apply方法:
    语法:apply([thisObj[,argArray]])
    概念:应用某一对象的一个方法,用另一个目标替换当前目的。
    说明:
    若果 argArray 不是一个灵光的数组或者不是 arguments
    对象,那么将招致一个 TypeError。
    假使没有提供 argArray 和 thisObj 任何一个参数,那么 Global
    对象将被当作 thisObj, 并且不能被传送任何参数.

  2. function bind
    this.x = 9
    9
    var module = {
    x:81,
    getX: function(){
    return this.x
    }
    }
    module.getX()
    81
    var getX = module.getX
    getX()
    9
    var boundGetX = getX.bind(module)
    boundGetX()
    81
    function add(a,b,c){
    return a + b + c
    }
    var func =add.bind(undefined, 100)
    func(1,2)
    103
    var func2 =func.bind(undefined, 200)
    func2(100)
    400
    function getConfig(color, size, otherOptions){
    console.log(color, size, otherOptions)
    }
    var defaultConfig = getConfig.bind(null, “#000”, “1024 * 768”)`
    defaultConfig(“123”)
    #000 1024 *澳门葡京, 768 123
    defaultConfig(“456”)
    #000 1024 * 768 456

  3. 闭包 //允许一个函数在当下词法功效域外调用时,仍可以访问当地变量
    优点: //灵活、 方便
    缺陷: //浪费空间、内存走漏、质量消耗

  4. arguments caller callee
    arguments :
    // 在函数调用时, 会自动在该函数内部生成一个名为
    arguments的潜伏对象。 该对象类似于数组,
    //但又不是数组。可以选取[]操作符获取函数调用时传递的实参。

    caller :
    //在一个函数调用另一个函数时,被调用函数会自动生成一个caller属性,指向调用它的函数对象。
    //倘使该函数当前未被调用,或不用被其他函数调用,则caller为null。

    callee :
    //当函数被调用时,它的arguments.callee对象就会指向自身,也就是一个对协调的引用。
    //由于arguments在函数被调用时才使得,因而arguments.callee在函数未调用时是不设有的(即null.callee),且解引用它会暴发格外。
    //

  5. this

    在函数执行时,this 总是指向调用该函数的目的。要判断 this
    的针对性,其实就是判定 this 所在的函数属于哪个人。

    在《javaScript语言精彩》那本书中,把 this
    出现的景色分为四类,简而言之就是:

    有目的就针对调用对象
    没调用对象就本着全局对象
    用new构培养对准新对象
    通过 apply 或 call 或 bind 来改变 this 的所指。
    1)函数有所属对象时:指向所属对象

    函数有所属对象时,日常经过 . 表明式调用,那时 this
    自然指向所属对象。比如上面的例子:

    var myObject = {value: 100};
    myObject.getValue = function () {
    console.log(this.value); // 输出 100

    // 输出 { value: 100, getValue: [Function] },
    // 其实就是 myObject 对象自我
    console.log(this);

    return this.value;
    };

    console.log(myObject.getValue()); // => 100
    getValue() 属于对象 myObject,并由 myOjbect 举办 . 调用,由此 this
    指向对象 myObject。

    1. 函数没有所属对象:指向全局对象

    var myObject = {value: 100};
    myObject.getValue = function () {
    var foo = function () {
    console.log(this.value) // => undefined
    console.log(this);// 输出全局对象 global
    };

    foo();

    return this.value;
    };

    console.log(myObject.getValue()); // => 100
    在上述代码块中,foo 函数即便定义在 getValue
    的函数体内,但其实它既不属于 getValue 也不属于 myObject。foo
    并没有被绑定在其余对象上,所以当调用时,它的 this 指针指向了全局对象
    global。

    据称那是个规划不当。

    3)构造器中的 this:指向新目的

    js 中,大家经过 new 关键词来调用构造函数,此时 this
    会绑定在该新对象上。

    var SomeClass = function(){
    this.value = 100;
    }

    var myCreate = new SomeClass();

    console.log(myCreate.value); // 输出100
    顺便说一句,在 js
    中,构造函数、普通函数、对象方法、闭包,那四者没有显著界线。界线都在人的心田。

    1. apply 和 call 调用以及 bind 绑定:指向绑定的靶子

    apply()
    方法接受多个参数第四个是函数运行的成效域,此外一个是一个参数数组(arguments)。

    call() 方法首个参数的意思与 apply()
    方法一致,只是其他的参数必要一个个列举出来。

    大致来说,call 的法门更近乎大家平日调用函数,而 apply 需求大家传递
    Array 方式的数组给它。它们是可以相互转换的。

    var myObject = {value: 100};

    var foo = function(){
    console.log(this);
    };

    foo(); // 全局变量 global
    foo.apply(myObject); // { value: 100 }
    foo.call(myObject); // { value: 100 }

    var newFoo = foo.bind(myObject);
    newFoo(); // { value: 100 }

  6. 闭包的一个坑
    换个思路清楚Javascript中的this,的多种采纳情状。闭包这几个定义,在函数式编程里很广泛,简而言之,就是使其中函数可以访问定义在表面函数中的变量。
    for (var i = 0; i < 5; i++) {
    setTimeout(function () {
    console.log(i);
    }, 5);
    }
    上边这些代码块会打印多个 5 出来,而我辈预料的结果是打印 1 2 3 4
    5。
    故而会如此,是因为 setTimeout 中的 i 是对外围 i 的引用。当
    set提姆eout 的代码被诠释的时候,运行时只是记录了 i
    的引用,而不是值。而当 set提姆eout 被触发时,八个 set提姆eout 中的 i
    同时被取值,由于它们都指向了外围的同一个 i,而那几个 i
    的值在迭代成功时为 5,所以打印了两回 5。
    为了取得大家预料的结果,我们得以把 i
    赋值成一个片段的变量,从而摆脱外层迭代的震慑。

    for (var i = 0; i < 5; i++) {
    (function (idx) {
    setTimeout(function () {
    console.log(idx);
    }, 5);
    })(i);
    }

从call方法开头

call 方法允许切换函数执行的上下文环境(context),即 this
绑定的靶子。

绝一大半介绍 this 的稿子中都会把 call
方法放到最终介绍,但此文我们要把 call 方法放在第二位介绍,并从
call 方法切入来商量 this ,因为 call 函数是显式绑定 this
的对准,大家来探视它什么模拟已毕(不考虑传入 nullundefined
和原始值):

Function.prototype.call = function(thisArg) { var context = thisArg; var
arr = []; var result; context.fn = this; for (let i = 1, len =
arguments.length; i < len; i++) { arr.push(‘arguments[‘ + i + ‘]’);
} result = eval(“context.fn(” + arr + “)”); delete context.fn; return
result; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Function.prototype.call = function(thisArg) {
    var context = thisArg;
    var arr = [];
    var result;
 
    context.fn = this;
 
    for (let i = 1, len = arguments.length; i < len; i++) {
        arr.push(‘arguments[‘ + i + ‘]’);
    }
 
    result = eval("context.fn(" + arr + ")");
 
    delete context.fn;
 
    return result;
}

从以上代码大家得以见见,把调用 call
方法的函数作为第四个参数对象的办法,此时一定于把第三个参数对象作为函数执行的上下文环境,而
this 是指向函数执行的上下文环境的,因而 this
就本着了首个参数对象,完毕了 call
方法切换函数执行上下文环境的功效。

在函数中 this
到底取何值,是在函数真正被调用执行的时候确定下来的,函数定义的时候确定不了。

2. 函数代码中的this

      共有多样函数调用形式:

     
1)方法调用方式:作为指标属性调用,obj.func();(详见8.目的中的this)

 
    2)函数调用格局:指向全局,间接调用func();     (详见1.全局代码中this)

      3)构造器调用形式:使用new调用;  
                (详见6.当作构造器调用的函数中的this)

 
    4)call/apply调用格局:动态改变this指向。        
(详见7.手动设置函数调用时this的值) 

 

     
函数代码中this值的首先个特性,同时也是最关键的特征,即:它不用静态地绑定在函数上。

      this的值是在进入执行上下文(Context
Excution)的级差确定的,在函数代码中,其值每一遍都有差异。不过进入实践代码阶段,其值就不可以改变。

     
即便想给this赋一个新值是不容许的,因为在那儿this根本就不是变量了。

      结合例子来分析:

var foo = {
    name: “Foo”
};
var bar= {
    name: “ting”,
    sayName: function() {
        console.log(this ===
bar);
        console.log(“My name is: ” + this.name);
    }
};
bar.sayName();   //true My name is: ting
foo.sayName = bar.sayName;
foo.sayName();      //false My name is: Foo

     
通过上述结果分析可见:调用bar对象的sayName方法时,this指向bar对象。通过赋值情势使得foo的sayName方法指向bar的sayName方法,再调用foo对象的sayName方法时,this指向foo对象。Why?

     
this的值在函数中是非静态的,它的值确定是在举行代码阶段(函数调用时,具体代码执行前)。this的值是由激活上下文代码的调用者提供的,比如调用函数的外围上下文,更首要的是,this的值是由调用表明式的花样操纵的。由此说,this并非静态绑定在函数上。

     
由于this非静态地绑定在函数上,那么大家是否可以在函数中动态地修改this的值吗?

var foo = {
    name: “Foo”
};
var person = {
    name: “ting”,
    sayName: function() {
        console.log(this == person);
        this = foo;
        console.log(“My name is: ” + this.name);
    }
};
person.sayName();   //My name is Foo
foo.sayName = person.sayName;
foo.sayName();      //My name is ting

     
在sayName方法中,动态地修改this的值,重新履行以上的代码,发现this的值引用错误。那是由于一旦进入代码执行阶段(函数调用时,执行代码前),this的值确定,不可以被改变。

      潜移默化函数代码中this值变化的元素:在常常的函数调用中,this是由激活上下文代码的调用者来提供的,即调用函数的父上下文(parent
context)。this值取决于调用函数的办法。 

     
误区:一些小说或JavaScript书籍中涉及:this值取决于函数定义的艺术,如若它是大局函数,this设置为大局对象,假若它是一个对象的格局,那么this总是指向这几个目的。那是纯属不科学的。

      切记一点:正是调用函数的主意影响了上下文中this的值。

      eg:
全局函数被调用方式的分化式样激活,不相同的调用方式导致了分歧的this值。

function foo() {
    console.log(this);
}
foo();  //Window

console.log(foo == foo.prototype.constructor);  //true
foo.prototype.constructor();  //foo {}

      eg: 对象定义的办法,执行该方法,this值未必指向该目的。

var foo = {
    bar: function() {
        console.log(this);
        console.log(this === foo);
    }
};
foo.bar(); //foo true
var fooTest = foo.bar;
console.log(fooTest === foo.bar);
//同一个function,分歧的调用表达式,this值分裂
fooTest(); //Window false

      调用形式怎样影响this的值?
为充裕领悟this值的规定,需求详细分析其内部类型之一,即引用类型(Reference
type)。

 

对象方法中的this

在模拟 call 方法的时候,大家运用了对象方法来改变 this
的对准。调用对象中的方法时,会把目的作为艺术的上下文环境来调用。

既然 this
是指向执行函数的上下文环境的,那大家先来商讨一下调用函数时的推行上下文情状。

上面我门来看看调用对象方法时实施上下文是何等的:

var foo = { x : 1, getX: function(){ console.log(this.x); } }
foo.getX();

1
2
3
4
5
6
7
var foo = {
    x : 1,
    getX: function(){
        console.log(this.x);
    }
}
foo.getX();

澳门葡京 2

从上图中,我们可以观看getX艺术的调用者的上下文是foo,因此getX格局中的
this 指向调用者上下文foo,转换成 call
方法为foo.getX.call(foo)

下边大家把其余函数的调用方式都按调用对象方法的思绪来更换。

因为 this
的取值是函数执行上下文(context)的一局地,每便调用函数,都会时有爆发一个新的举行上下文环境。当代码中行使了
this,那几个 this
的值就间接从举行的上下文中获取了,而不会从效果域链中查找。

3. 引用类型(Reference Type)

     
使用伪代码将引用类型的值表示为持有几个特性的靶子,包括base(拥有属性的不行目标),对象中的propertyName(属性名)。

var valueofRefereceType = {
    base: <base object>,
    propertyName: <property name>
};

      引用类型的值唯有二种情景:

1)当我们处理一个标识符时

2)或性质访问器

     
标识符的处理进度另作商讨,近日只需精通,该算法的再次来到值中,总是一个引用类型的值,那对于this来说更加首要。

     
标识符是:变量名、函数名、函数参数名或全局对象中未识其余属性名。例如,下边标识符的值:

var foo;
function bar() { } 

      在操作当中结果的经过中,引用类型对应的值如下:

var fooReference = {
    base: global,
    propertyName: ‘foo’
};

var barReference = {
    base: global,
    propertyName: ‘bar’
};

      伪代码GetValue描述从一个引用类型中赢得目标真正的值。

function GetValue(value) {
    if( Type(value) != Reference) {
        return value;
    }
    var base = GetBase(value);
    if(base === null) {
        throw return new ReferenceTypeError;
    }
    return base.[[Get]](GetPropertyName(value));
}

     
内部的[[Get]]措施再次来到对象属性真正的值,包罗对原型链中继承的特性分析。

GetValue(fooReference); // 10
GetValue(barReference); // function object “bar”

      属性访问器:点(.)语法或括号([])语法

foo.bar();
foo[‘bar’]();

      在当中总计的重临值中,引用类型的值为:

var fooReference = {
    base: foo,
    propertyName: ‘bar’
};

GetValue(fooReference); // function object “bar”

   
  引用类型的值域函数上下文中的this怎么样相关?
–从最要紧的意思上的话。

 那些涉及的进度是那篇文章的大旨。

      一个函数上下文中,确定this值的通用规则如下:

1)在一个函数上下文中,this由调用者提供,由调用函数的不二法门来决定。

2)假若调用括号()的左手是引用类型的值,this值将设为引用类型值的base对象(base
object)。

3)若是调用括号()的左手不是援引类型的值(与引用类型类型不相同的其余其余性质),this值为null,但是事实上不设有this值为null的情形,因为当this值为null的时候,其值会被隐示转换为全局对象。(注:第5版的ECMAScript,已经不强迫转换为全局变量,而是赋值为undefined。) 

      看些例子,领会函数上下文中this值。

function foo() {
    console.log(this);
}
foo(); //window

      调用括号()的左侧是引用类型的值,因为foo是一个标识符。

var fooReference = {
    base: global,
    propertyName: ‘foo’
};

      相应地,this设置为引用类型的base对象,即全局对象。

      使用性质访问器:

var foo = {
    bar: function() {
        console.log(this);
    }
};
foo.bar(); //foo

     
大家重新拥有一个引用类型,其base是foo对象,在函数bar激活时用作this。

var fooBarReference = {
    base: foo,
    propertyName: ‘bar’
};

      不过,使用别的一种格局激活相同的函数,大家得到其余的this值。

var foo = {
  bar: function () {
    console.log(this);
  }
};
var test = foo.bar;
test(); 

//window

     
因为test作为标识符,生成了引用类型的其余值,其base(全局对象)用作this的值。

var testReference = {
    base: global,
    propertyName: ‘test’
};

     
从上述例子中可以分析得知:使用差别的表达式激活函数为什么会促成不一样的this值,原因在于变更了引用类型(Type
Reference)不相同的中间值
。  

      再看三个例证,加深映像。

var foo = function() {
    console.log(this);
};
foo(); //window,because
var fooReference = {
    base: global,
    propertyName: ‘foo’
};

console.log(foo = foo.prototype.constructor);
//其余一种样式的调用表明式
foo.prototype.constructor(); //foo.prototype,because
var fooPrototypeConstructor = {
    base: foo.prototype,
    propertyName: ‘constructor’
};

      通过调用格局动态确定this值的经典例子。

function foo() {
    console.log(this.bar);
}
var x = {bar: 10};
var y = {bar: 20};
x.test = foo;
y.test = foo;

x.test(); //10
y.test(); //20

      

构造函数中的this

function Foo(){ this.x = 1; this.getX = function(){ console.log(this.x);
} } var foo = new Foo(); foo.getX();

1
2
3
4
5
6
7
8
function Foo(){
    this.x = 1;
    this.getX = function(){
        console.log(this.x);
    }
}
var foo = new Foo();
foo.getX();

执行 new
假设不考虑原型链,只考虑上下文的切换,就一定于先创立一个空的对象,然后把这几个空的目的作为构造函数的上下文,再去实施构造函数,最终回来这一个目的。

var newMethod = function(func){ var context = {}; func.call(context);
return context; } function Foo(){ this.x = 1; this.getX = function(){
console.log(this.x); } } var foo = newMethod(Foo); foo.getX();

1
2
3
4
5
6
7
8
9
10
11
12
13
var newMethod = function(func){
    var context = {};
    func.call(context);
    return context;
}
function Foo(){
    this.x = 1;
    this.getX = function(){
        console.log(this.x);
    }
}
var foo = newMethod(Foo);
foo.getX();

至于 this 的取值,大体上可以分成以下两种情景:

4. 函数调用和非引用类型

     
正如前方所提到的,当调用括号的左手不是援引类型而是别的品类,这几个值自动安装为null,结果为大局对象。

      思考如下那种表达式:

(function () {
    console.log(this);
})(); //null —> global

     
在那些例子中,大家有一个函数对象但不是引用类型的靶子(它不是标识符,也不是性质选取器),相应地,this值最后设为全局对象。

      越来越多复杂的例子:

var foo = {
    bar: function() {
        console.log(this);
    }
};
foo.bar(); //foo
(foo.bar)(); //foo

(foo.bar = foo.bar)(); //Window
(false || foo.bar)(); //Window
(foo.bar, foo.bar)(); //Window

     
一个品质访问器,它的中间值应该是引用类型的值,不过在少数调用中,大家赢得的this值不是base对象,而是global对象。Why?

     
原因在于前面3个的调用中,应用一定的操作符之后,调用括号左边的值不再是援引类型的值。

      第三个例子 — 调用括号右边是援引类型的值,this为base对象,即foo;

      第四个例子 —
组运算符并不适用,如上边所关联的,从引用类型获取一个对象真正值的主意,如GetValue。
相应地,在组运算的归来中,得到的仍是一个引用类型。由此this值再度被设为base对象,即foo;

      第三个例子 —
与组操作符差距,赋值运算符触发了GetValue方法,重回的结果是函数对象,而不是引用类型的值,那象征this值会被装置为null,最后会被变成全局对象。

      第八个例证 — 逻辑或运算符触发了GetValue方法,重返的结果……

      第多个例证 — 逗号运算符触发了GetValue方法,重回的结果是…… 

 

澳门葡京 3

境况一:全局 & 调用一般函数

5. 引用类型和this为null

     
例外的动静:调用括号左边是援引类型的值,但this却为null,最后被隐示转换为全局对象(global
object)。景况建立的标准化是:当引用类型值的base对象恰好为活跃对象(activiation
object)。例如:其间子函数在父函数中被调用。一对变量、内部函数、方式参数存储在给定函数的激活对象中。 
 

function foo() {
  function bar() {
    console.log(this); // Window
  }
  bar(); // the same as AO.bar()
}

foo(); 

     
活跃对象总是作为this重临,值为null(用伪代码表示AO.bar()相当于null.bar())。正如上面例子提到的,this的值最后由null隐示转换为大局对象。

      上述例子的变形:

function foo() {
  function bar() {
    console.log(this); // Window
  }
  return bar(); // the same as AO.bar()
}
foo(); 

      有一种意况与上述意况又分化:使用with。

     
尽管with对象涵盖函数属性,并且在with语句块中调用该函数。with语句会将该目的添加到成效域链的最前边,即在活泼对象从前。相应地,有了引用类型的值(标识符或性质访问器),其base对象不再是虎虎有生气对象,而是with语句对象。其余,值得一提的是,它不仅仅只针对内部函数,也本着全局函数,原因在于with对象比成效域链最前头的目的(全局对象或活跃对象)还要靠前。

var x =10;
with({
    foo: function() {
        console.log(this.x);
    },
    x: 20
}) {
    foo();  //20
}

//because
var fooReference = {
    base: _withObject,
    propertyName: ‘foo’
};

     
同样的景观出现在catch语句的实际上参数中函数调用,catch对象添加到成效域的最前端,即运动对象或全局对象的面前。可是,那一个一定的一颦一笑被认可为ECMAScript-262-3的bug,在ECMAScript-262-5中被修复了。那样,在一定的移位目标中,this不是指向catch对象,而是指向全局对象。

try {
    throw function() {
        console.log(this);
    };
} catch (e) {
    e();  //ES3正式里是_catchObject,ES5正经里是Window
}
//ES3
var eReference = {
    base: _catchObject,
    propertyName: ‘e’
};
//ES5
var eReference = {
    base: global,
    propertyName: ‘e’
};

     
同样的图景出现在命名函数的递归调用中。在率先次递归调用中,base对象是父活跃对象或全局对象,在递归调用中,base对象应该是储存着函数表明式可选名称的一定目的。不过,在那种情状下,this总是指向全局对象。

(function foo(bar) {
  alert(this);
  !bar && foo(1);
})();

 

DOM事件处理函数中的this

DOMElement.addEventListener(‘click’, function(){ console.log(this); });

1
2
3
DOMElement.addEventListener(‘click’, function(){
    console.log(this);
});

把函数绑定到DOM事件时,可以当作在DOM上扩展一个函数方法,当接触这么些事件时调用DOM上相应的风云措施。

DOMElement.clickHandle = function(){ console.log(this); }
DOMElement.clickHandle();

1
2
3
4
DOMElement.clickHandle = function(){
    console.log(this);
}
DOMElement.clickHandle();

澳门葡京 4

在全局环境中,this 永远指向 window。

6. 当作构造器调用的函数中的this

     
函数作为构造函数时,通过new操作符创制对象实例的历程包罗:首先调用Foo()函数内部的[[construct]]主意,其次,在目的成立之后,调用内部的[[call]]格局。所有同一的函数“Foo”将this设置为新创造的靶子

function Foo() {
    console.log(this);
    this.x = 10;
}
var a = new Foo();
console.log(a.x);

     
再看一例:Person不做为构造函数调用,而是作为一般函数在全局功能域中被调用,this指向Window,由此全局对象中的name被修改为mars。至于Person.name的值为空字符串,有点奇怪?
更奇怪的是将代码中Person函数的name全体换为zzz或任何标识,Person.zzz为undefined??
原因是:name是函数的一个内部参数,标识函数的名字,由于赋给Person的函数为匿名函数,由此name为空字符串,可是用其它标识符,由于Person中没有概念该属性,由此值为undefined。

var name = ‘window_mars’;
var Person = function (name) {
    this.name = name;
};
Person(‘mars’);
console.log(name);         //mars
var s1 = Person.name;      //””
var o = new Person(“ting”);
console.log(o.name);       //ting

     
上边的事例能够很好地证实name属性为函数自带的属性值,且其值不可能被覆盖。

var name = ‘window_mars’;
var Person = function (name) {
    this.name = name;
};
Person.name = name;
Person.name1 = name;
var s1 = Person.name;      //””
var s2 = Person.name1;     //”window_mars”
var o = new Person(“ting”);
console.log(o.name);       //ting

 

一般说来函数中的this

var x = 1; function getX(){ console.log(this.x); } getX();

1
2
3
4
5
var x = 1;
function getX(){
    console.log(this.x);
}
getX();

那种状态下,我们创造一个虚构上下文对象,然后普通函数作为这么些虚拟上下文对象的法子调用,此时一般性函数中的this就针对了那些虚拟上下文。

那这些编造上下文是何许吗?在非严谨格局下是大局上下文,浏览器里是
window ,NodeJs里是 Global ;在从严格局下是 undefined

var x = 1; function getX(){ console.log(this.x); } [viturl
context].getX = getX; [viturl context].getX();

1
2
3
4
5
6
7
var x = 1;
function getX(){
    console.log(this.x);
}
 
[viturl context].getX = getX;
[viturl context].getX();

澳门葡京 5

console.log(this === window);    //true

7. 手动设置函数调用时this的值(apply()、call()) 

     
Function.prototype原型上定义了七个形式,允许手动设置函数调用时的值,那七个法子分别是:apply()和call()。那五个办法都承受第四个参数作为调用上下文中this的值,而那多少个主意的分别是传递参数,对于apply()方法,第四个参数是数组类型(或类数组对象,比如arguments),而对于call()方法接受任意多的参数(逗号分隔)。那四个格局的第二个参数假诺不传或为null,那this的值为Window。

      例一: 

var b = 10;
function a(c) {
    console.log(this.b);
    console.log(c);
}
a(20); //this.b is 10, c is 20

a.apply({b:20},30); //this.b is 20, c is 30
b.apply({b:40},[40]); //this.b is 40, c is 40

      例二:

var myObject = {};
var myFunction = function(param1, param2) {
    this.x = param1;
    this.y = param2;
    console.log(this); //Object {x: “kkk”, y: “ooo”} 
};
myFunction.apply(myObject, [“kkk”, “ooo”]);
console.log(myObject); //Object {x: “kkk”, y: “ooo”} 
myFunction.call(myObject, “kkk”, “ooo”);
console.log(myObject); //Object {x: “kkk”, y: “ooo”} 

闭包中的this

var x = 1; var foo = { x: 2, y: 3, getXY: function(){ (function(){
console.log(“x:” + this.x); console.log(“y:” + this.y); })(); } }
foo.getXY();

1
2
3
4
5
6
7
8
9
10
11
12
var x = 1;
var foo = {
    x: 2,
    y: 3,
    getXY: function(){
        (function(){
            console.log("x:" + this.x);
            console.log("y:" + this.y);
        })();
    }
}
foo.getXY();

那段代码的上下文如下图:澳门葡京 6

那边需求专注的是,大家再研商函数中的 this 指向时,只需求关爱
this 所在的函数是什么调用的, this
所在函数外的函数调用都是浮云,是不须求关爱的。因而在拥有的图示中,大家只必要关心粉色框中的内容。

为此那段代码大家关心的有的唯有:

(function(){ console.log(this.x); })();

1
2
3
(function(){
    console.log(this.x);
})();

与日常函数调用一样,成立一个虚拟上下文对象,然后普通函数作为这么些编造上下文对象的主意立时调用,匿名函数中的
this
也就对准了那么些虚拟上下文。澳门葡京 7

平凡函数在调用时候(注意不是构造函数,后边不加 new),其中的 this 也是指向
window。

8. 目的中的this

     
对象中this值的判断,其实说到底也牵涉到函数中this值的判定,由此可比照函数上下文中this值的论断规则来确定this值。
看上边多少个例子。

     
函数getName()上下文中this值的判定,引用类型中间值的base对象是person对象,this值为person对象,如上边代码所示。

var person = {
    name: “ting”,
    getName: function() {
        console.log(this); //Object {name: “ting”, getName: function}
        console.log(this.name); //ting
    }
};
person.getName();

     
函数getName()和getGlobalName()上下文中this值的判断,this值分别为person对象和全局对象。

var name = “global-ting”;
function getGlobalName () {
    return this.name;
}
var person = {
    name: “ting”,
    getName: function() {
        return this.name;
    }
};
var s1 = person.getName(); //”ting”
var s2 = getGlobalName();  //”global-ting”

      上述例子的变形:

var name = “global-ting”;
function getGlobalName () {
    return this.name;
}
var person = {
    name: “ting”,
    getName: getGlobalName
};
var s1 = person.getName(); //”ting”
var s2 = getGlobalName();  //”global-ting”

      上述例子的变形:

function getGlobalName () {
    return this.name;
}
var person = {
    name: “ting”,
    getName: getGlobalName
};
var hehe = {
    name: “haha”,
    getName: getGlobalName
}
var s1 = person.getName(); //”ting”
var s2 = getGlobalName();  //”global-ting”
var s3 = hehe.getName(); //”haha”

参数中的this

var x = 1; var foo = { x: 2, getX: function(){ console.log(this.x); } }
setTimeout(foo.getX, 1000);

1
2
3
4
5
6
7
8
var x = 1;
var foo = {
    x: 2,
    getX: function(){
        console.log(this.x);
    }
}
setTimeout(foo.getX, 1000);

函数参数是值传递的,由此地方代码等同于以下代码:

var getX = function(){ console.log(this.x); }; setTimeout(getX, 1000);

1
2
3
4
var getX = function(){
    console.log(this.x);
};
setTimeout(getX, 1000);

下一场大家又重返了普通函数调用的标题。

var x = 10;

9. DOM事件中的this

      示例一:el指向绑定该事件的dom元素,事件处理程序中的this指向Window

<script type=”text/javascript”>
        function test_this(el) {
            var element = el;
            var scope = this;
        }
</script>
<div id=”news” class=”overlay” onclick=”test_this(this);”>点击我</div>

澳门葡京 8   

     
示例二:event指向触发的风波Mouse伊芙nt,this指向绑定该事件的DOM元素。

<script type=”text/javascript”>
    function test_this(event) {
        var e = event;
        var scope = this;
    }
    document.getElementById(“news”).onclick = test_this;
</script>
<div id=”news” class=”overlay”>点击我</div>

澳门葡京 9 
 澳门葡京 10

     
示例三:与示例二的结果同样,即event指向事件Mouse伊芙nt,this为绑定该事件的DOM元素。

<script type=”text/javascript”>
    function test_this(event) {
        var e = evemt;
        var scope = this;
    }
    document.getElementById(“news”).addEventListener(“click”, test_this, false);
</script>
<div id=”news” class=”overlay”>点击我</div>

 

大局中的this

大局中的 this 指向全局的上下文

var x = 1; console.log(this.x);

1
2
var x = 1;
console.log(this.x);

澳门葡京 11

function foo(){

10. 检测一下

     
exam1:baz为全局变量,函数执行完后,没有被释放;bar为部分变量,函数立刻施行完,该变量被假释,因而报错。

(function () {
    baz = 5;
    var bar = 10;
})();
console.log(baz); //5

console.log(bar); //报错,ReferenceError:bar is not defined.

      exam2:严刻方式下会报错:ReferenceError:bar is not defined.

“use strict”;
(function () {
    baz = 5;   //报错
    var bar = 10;
})();
console.log(baz);

      exam3:两处的a都是在全局域中被操作。

a = 2;
var a = 1;
console.log(a); //1

 

      终于整理完了^-^.

 

 

 

时间:2014-10-19

地点:合肥 

引用:

        

        

 

复杂气象下的this

var x = 1; var a = { x: 2, b: function(){ return function(){ return
function foo(){ console.log(this.x); } } } }; (function(){ var x = 3;
a.b()()(); })();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var x = 1;
var a = {
    x: 2,
    b: function(){
        return function(){
            return function foo(){
                console.log(this.x);
            }        
        }
    }
};
 
(function(){
    var x = 3;
    a.b()()();
})();

总的来看上边的事态是有比比皆是个函数,但我们只需求关注 this
所在函数的调用格局,首先咱们来简化一下之类:

var x = 1; (function(){ var x = 3; var foo = function(){
console.log(this.x); } foo(); });

1
2
3
4
5
6
7
8
var x = 1;
(function(){
    var x = 3;
    var foo = function(){
        console.log(this.x);
    }
    foo();
});

this 所在的函数 foo
是个常见函数,我们创造一个虚拟上下文对象,然后普通函数作为那一个虚拟上下文对象的章程登时调用。因而那个
this针对了这一个虚拟上下文。在非严苛形式下是大局上下文,浏览器里是
window ,NodeJs里是 Global ;在严俊形式下是 undefined

console.log(this);    //Window

总结

在要求判定 this 的针对时,我们可以安装那种思路来驾驭:

  • 判断 this 在大局中OR函数中,若在大局中则 this
    指向全局,若在函数中则只关怀这么些函数并屡次三番判断。
  • 判断 this 所在函数是不是作为对象方法调用,即使则 this
    指向那个目标,否则继续操作。
  • 创造一个虚构上下文,并把this所在函数作为那些编造上下文的法子,此时
    this 指向那一个虚拟上下文。
  • 在非严俊方式下虚拟上下文是大局上下文,浏览器里是 window
    ,Node.js里是 Global ;在严苛方式下是 undefined

图示如下:

澳门葡京 12

 

1 赞 6 收藏
评论

澳门葡京 13

console.log(this.x);  //10

}

foo();

状态二:构造函数

所谓的构造函数就是由一个函数 new
出来的对象,一般构造函数的函数名首字母大写,例如像
Object,Function,Array 那个都属于构造函数。

function Foo(){

this.x = 10;

console.log(this);    //Foo {x:10}

}

var foo = new Foo();

console.log(foo.x);      //10

上述代码,要是函数作为构造函数使用,那么内部的 this 就表示它即将 new
出来的目标。

不过若是向来调用 Foo 函数,而不是 new Foo(),那就变成意况1,那时候 Foo()
就改成平时函数。

function Foo(){

this.x = 10;

console.log(this);    //Window

}

var foo = Foo();

console.log(foo.x);      //undefined

状态三:对象方法

设若函数作为靶子的不二法门时,方法中的 this 指向该对象。

var obj = {

x: 10,

foo: function () {

console.log(this);        //Object

console.log(this.x);      //10

}

};

obj.foo();

专注:假使在对象方法中定义函数,那么情形就不一致了。

var obj = {

x: 10,

foo: function () {

function f(){

console.log(this);      //Window

console.log(this.x);    //undefined

}

f();

}

}

obj.foo();

可以那样驾驭:函数 f 即使是在 obj.foo
内部定义的,但它仍旧属于一个见惯不惊函数,this 仍指向 window。

在那边,要是想要调用上层成效域中的变量 obj.x,可以使用 self 缓存外部
this 变量。

var obj = {

x: 10,

foo: function () {

var self = this;

function f(){

console.log(self);      //{x: 10}

console.log(self.x);    //10

}

f();

}

}

obj.foo();

借使 foo 函数不作为对象方法被调用:

var obj = {

x: 10,

foo: function () {

console.log(this);      //Window

console.log(this.x);    //undefined

}

};

var fn = obj.foo;

fn();

obj.foo 被赋值给一个全局变量,并从未作为 obj 的一个属性被调用,那么此时
this 的值是 window。

气象四:构造函数 prototype 属性

function Foo(){

this.x = 10;

}

Foo.prototype.getX = function () {

console.log(this);        //Foo {x: 10, getX: function}

console.log(this.x);      //10

}

var foo = new Foo();

foo.getX();

在 Foo.prototype.getX 函数中,this 指向的 foo
对象。不仅仅如此,即使是在全体原型链中,this 代表的也是眼前目的的值。

情况五:函数用 call、apply或者 bind 调用。

var obj = {

x: 10

}

function foo(){

console.log(this);    //{x: 10}

console.log(this.x);  //10

}

foo.call(obj);

foo.apply(obj);

foo.bind(obj)();

当一个函数被 call、apply 或者 bind 调用时,this 的值就取传入的靶子的值。

情况六:DOM event this

在一个 HTML DOM 事件处理程序里,this 始终指向这么些处理程序所绑定的 HTML
DOM 节点:

function Listener(){

document.getElementById(‘foo’).add伊夫ntListener(‘click’,
this.handleClick);    //那里的 this 指向 Listener
那么些目的。不是强调的是此处的 this

}

Listener.prototype.handleClick = function (event) {

console.log(this);    //

}

var listener = new Listener();

document.getElementById(‘foo’).click();

那么些很好了解,就一定于是给函数传参,使 handleClick
运行时上下文改变了,相当于上边那样的代码:

var obj = {

x: 10,

fn: function() {

console.log(this);        //Window

console.log(this.x);      //undefined

}

};

function foo(fn) {

fn();

}

foo(obj.fn);

您也可以用经过 bind 切换上下文:

function  Listener(){

document.getElementById(‘foo’).addEventListener(‘click’,this.handleClick.bind(this));

}

Listener.prototype.handleClick = function (event) {

console.log(this);    //Listener {}

}

var listener = new Listener();

document.getElementById(‘foo’).click();

前各样状态其实可以计算为: this 指向调用该办法的目的。

状态七:箭头函数中的 this

当使用箭头函数的时候,处境就截然不相同了:箭头函数内部的 this
是词法效用域,由上下文确定。

var obj = {

x: 10,

foo: function() {

var fn = () => {

return () => {

return () => {

console.log(this);      //Object {x: 10}

console.log(this.x);    //10

}

}

}

fn()()();

}

}

obj.foo();

近日,箭头函数完全修复了 this 的针对性,this
总是指向词法功能域,也就是外围调用者 obj。

一经利用箭头函数,之前的那种 hack 写法:

var self = this;

就不再须要了。

var obj = {

x: 10,

foo: function() {

var fn = () => {

return () => {

return () => {

console.log(this);    // Object {x: 10}

console.log(this.x);  //10

}

}

}

fn.bind({x: 14})()()();

fn.call({x: 14})()();

}

}

obj.foo();

是因为 this 在箭头函数中早已根据词法成效域绑定了,所以,用 call()或者
apply()调用箭头函数时,不可以对 this 举行绑定,即传入的率先个参数被忽视。

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website