this 订阅
This,英语单词,发音:[英][ðɪs][美][ðɪs]。常翻译为:这,这么。 展开全文
This,英语单词,发音:[英][ðɪs][美][ðɪs]。常翻译为:这,这么。
信息
java
关键字
外文名
This
翻    译
这, 本,这么
其    他
烟名
属    性
英语单词
This例句
This ship docked this morning.这条船是今天早上靠的码头。.This new approach is新方案有:.A downpour this afternoon下午有瓢泼大雨.For this particular purpose为某一特别目的.Move this heavy box把这重箱子挪动Pecified by doing this将某物挤成某形状、大小等Person who does this(使人感到)忧愁的,沮丧的.Shop operating this system现款自运商店(实行上述制度的商店).Wish this delay tolerate望原谅我的延误。.This work continues. This story goes on.这项工作必须继续下去。
收起全文
精华内容
下载资源
问答
  • this与bind(this)

    万次阅读 多人点赞 2019-02-23 17:34:52
    文章目录this与bind(this)thisthis详细- 全局环境- 函数内1. 普通函数2. 箭头函数3. 对象中的函数原型链中的thisgetter 与 setter 中的 thisbind(this) ReactNative系列-文章 this与bind(this) this this指向的是...


    ReactNative系列-文章

    this与bind(this)

    this

    this指向的是当前函数的作用域(对象实例),有如下的例子

      const app = {
        name: 'xiaoming',
        log() {
          console.log(this.name);
        },
        child() {
          return {
            name: 'b',
            log() {
              console.log(this.name);
            },
          };
        },
      };
      app.log(); // xiaoming
      app.child().log(); // b
    

    this详细

    - 全局环境

    无论是否在严格模式(‘use strict’)下,在全局执行环境中(在任何函数体外部)this 都指向全局对象。

    console.log(this === window); // true
    
    this.name = 'react';
    console.log(name); // react
    console.log(window.name); // react
    

    - 函数内

    在函数内部,this的值取决于函数被调用的方式。

    1. 普通函数

    非严格模式下,this默认指向全局对象。

    function f() {
      return this;
    }
    
    // brower
    f() === window;
    // node
    f() === global;
    

    严格模式下,this默认指向调用函数的对象实例。

    function f() {
      'use strict'
      return this;
    }
    f() === undefined;
    

    因为这里的f()是直接调用的,而不是作为对象的属性或方法调用的,如window.f(),所以这里的this为undefined。

    如果要想把 this 的值从一个环境传到另一个,就要用 call 或者apply 方法。

    var obj = {a: 'Custom'};
    
    // 这个属性是在global对象定义的。
    var a = 'Global';
    
    function whatsThis(arg) {
      return this.a;  // this的值取决于函数的调用方式
    }
    
    whatsThis();          // 'Global'
    whatsThis.call(obj);  // 'Custom'
    whatsThis.apply(obj); // 'Custom'
    

    在JavaScript定义的函数都继承自Function,我们可以通过Function.prototype属性里的call或apply方法将 this 值绑定到调用中的特定对象。

    function add(c, d) {
      return this.a + this.b + c + d;
    }
    
    var o = {a: 1, b: 3};
    
    // 第一个参数是作为‘this’使用的对象
    // 后续参数作为参数传递给函数调用
    add.call(o, 5, 7); // 1 + 3 + 5 + 7 = 16
    // 第一个参数也是作为‘this’使用的对象
    // 第二个参数是一个数组,数组里的元素用作函数调用中的参数
    add.apply(o, [10, 20]); // 1 + 3 + 10 + 20 = 34
    

    使用 call 和 apply 函数的时候要注意,如果传递给 this 的值不是一个对象,JavaScript 会尝试使用内部 ToObject 操作将其转换为对象。因此,如果传递的值是一个原始值比如 7 或 ‘foo’,那么就会使用相关构造函数将它转换为对象,所以原始值 7 会被转换为对象,像 new Number(7) 这样,而字符串 ‘foo’ 转化成 new String(‘foo’) 这样,例如:

    function bar() {
      console.log(Object.prototype.toString.call(this));
    }
    
    //原始值 7 被隐式转换为对象
    bar.call(7); // [object Number]
    

    2. 箭头函数

    箭头函数没有自己的this指针。通过 call() 或 apply() 方法调用一个函数时,只能传递参数(不能绑定this)。在封闭的词法环境中,箭头函数的this和普通函数的this一致;在全局代码里,箭头函数的this被设置为全局对象。

    var obj = {
      bar: function() {
        var x = (()=> this);
        return x;
      }
    }
    // 以obj为对象来调用bar(),所以this绑定的是obj
    var fn = obj.bar();
    console.log(fn() === obj); // true
    
    // 这里并没有调用bar(),只是引用bar赋给fn2
    var fn2 = obj.bar;
    // 使用全局变量来调用bar(),所以这里的this绑定全局
    console.log(fn2()() == window);
    

    3. 对象中的函数

    当函数在对象中被调用时,this指向的是调用该函数的对象。

    const app = {
      name: 'xiaohong',
      f: function() {
        console.log(this.name);
      }
    }
    

    f() 函数里的this指向的是app对象。

    this 的绑定只受最靠近的成员引用的影响。例如:

    var o = {prop: 37};
    
    function independent() {
      return this.prop;
    }
    
    o.f = independent;
    
    console.log(o.f()); // logs 37
    
    o.b = {g: independent, prop: 42};
    console.log(o.b.g()); // 42
    

    事实证明,这与他是对象 o 的成员没有多大关系,最靠近的引用才是最重要的。

    原型链中的this

    如果该方法存在于一个对象的原型链上,那么this指向的是调用这个方法的对象,就像该方法在对象上一样。

    var o = {
      f: function() { 
        return this.a + this.b; 
      }
    };
    var p = Object.create(o);
    p.a = 1;
    p.b = 4;
    
    console.log(p.f()); // 5
    

    在这个例子中,对象p没有属于它自己的f属性,它的f属性继承自它的原型。虽然在对 f 的查找过程中,最终是在 o 中找到 f 属性的,这并没有关系;查找过程首先从 p.f 的引用开始,所以函数中的 this 指向p。也就是说,因为f是作为p的方法调用的,所以它的this指向了p。

    getter 与 setter 中的 this

    用作 getter 或 setter 的函数都会把 this 绑定到设置或获取属性的对象。

    bind(this)

    ES5 引入了 Function.prototype.bind。调用f.bind(someObject)会创建一个与f具有相同函数体和作用域的函数,但是在这个新函数中,this将永久地被绑定到了bind的第一个参数,无论这个函数是如何被调用的。bind绑定的参数只生效一次。

    function f(){
      return this.a;
    }
    
    var g = f.bind({a:"azerty"});
    console.log(g()); // azerty
    
    var h = g.bind({a:'yoo'}); // bind只生效一次!
    console.log(h()); // azerty
    

    传入bind的第二个参数以及后面的,依照先后顺序构成绑定函数的参数。

    var foo = {
        x: 3
    } 
    var bar = function(){
        console.log(this.x);
    } 
    bar(); // undefined
    
    var boundFunc = bar.bind(foo);
    
    boundFunc(); // 3
    

    有时候,我们须要保持this的上下文,也就是在一个运行环境中,想要訪问到的this值。在什么时候须要这么做呢?

    比方说将一个对象的方法赋值给了一个全局变量,然后在全局变量中调用这种方法,那么this值就不再是原来的对象而是window对象了。但是我们还需要依照对象的方法来调用。

    又比方说一个方法中包括了闭包,闭包是无法訪问到其外部函数的this对象的,由于this对象是在调用方法的时候自己主动生成,内部函数在搜索这两个变量的时候仅仅会搜索到其自身的活动对象。而不会沿着作用域链往外搜索,所以闭包訪问不到外部函数的this值。

    在react中,常看到

    export default class App extends Component {
      constructor(props) {
        super(props);
        this.foo = this.foo.bind(this);
      }
      
      foo() {
        // todo something
      }
      
      render() {
        return (
          <View>
            <Button onPress={this.foo}/>
          </View>
        )
      }
    }
    

    如果你传递一个函数名给一个变量,然后通过在变量后加括号’()'来调用这个方法,此时方法内部的this的指向就会丢失。这就会出现外部的foo方法内部的this会丢失指向。

    为了解决这个问题,我们需要在实例化对象的时候,需要在构造函数中绑定this,使得无论事件处理函数如何传递,它的this的指向都是固定的,固定指向我们所实例化的对象。

    展开全文
  • 一、学习this的指向问题 二、call和apply的特点与区别 三、模拟实现一个call 四、bind的功能 五、结尾 思考题+导图+示例代码,让你轻松掌握!

    this指向详解

    JavaScript基础提升合集

    🚀包含this、call、原型链、作用域等基础经典知识点
    ☕️每周一篇,打好基础,爬升不累
    💬最全知识点解析,易懂的代码示例收藏方便阅读
    💻完整版在线阅读,猛戳这里~

    目录

    前言+思考题

    记得当时找实习的时候,总是会在简历上加上一句——熟悉Js,例如this指向、call、apply等…

    而每次投递简历时我都会经历如下步骤

    • 面试前,去问度娘——this指向可以分为哪几种啊~、call和apply的区别是什么?底气由0% 猛涨到了 50%;
    • 面试中,面试官随便扔上来几道题,我都可以“坚定的”给出答案,结果总是不尽人意…
    • 面试后,我会羞愧的删除掉简历上的这一条。而再之后投递简历时我又再次加上了这一条…

    思考题

    下面几道题是我在网上搜索出来的热度较高的问题,如果大佬们可以轻松的回答上,并有清晰的思路,不妨直接点个赞吧(毕竟也消耗了不少脑细胞),如果大佬们能在评论处指点一二,就更好了!!!

    填空题:

    • 执行Javascript中的【 】函数会创建一个新函数,新函数与被调函数具有相同的函数体,当目标函数被调用时 this 值指向第一个参数。

    问答题:

    • 请你谈一下改变函数内部this指针的指向函数有哪几种,他们的区别是什么?
    • this的指向可以分为哪几种?

    代码分析题:

    var name = 'window'
    
    var person1 = {
      name: 'person1',
      show1: function () {
        console.log(this.name)
      },
      show2: () => console.log(this.name),
      show3: function () {
        return function () {
          console.log(this.name)
        }
      },
      show4: function () {
        return () => console.log(this.name)
      }
    }
    var person2 = { name: 'person2' }
    
    person1.show1()
    person1.show1.call(person2)
    
    person1.show2()
    person1.show2.call(person2)
    
    person1.show3()()
    person1.show3().call(person2)
    person1.show3.call(person2)()
    
    person1.show4()()
    person1.show4().call(person2)
    person1.show4.call(person2)()
    

    一、this的指向

    百度、谷歌上输入“this的指向”关键字,大几千条文章肯定是有的,总不至于为了全方面、无死角的掌握它就要将所有的文章都看一遍吧?所以不如梳理出一个稳固的框架,顺着我们的思路来填充它。

    思维导图

    在这里插入图片描述

    本节精华:

    • this 总是(非严格模式下)指向一个对象,而具体指向哪个对象是在运行时基于函数的执行环境动态绑定的,而非函数被声明时的环境;
    • 除了不常用的with和eval的情况,具体到实际应用中,this指向大概可以分为四种:
      • 作为对象的方法调用;
      • 作为普通函数调用;
      • 构造器调用;
      • call 或 apply调用;
      • 箭头函数中,this指向函数上层作用域的this;
    • 构造器普通函数的区别在于被调用的方式
    • A,call(B) => 可以理解成在B的作用域内调用了A方法;

    分析

    1、作为对象的方法调用

    当函数作为对象的方法被调用时,this指向该对象

    var obj = {
        a: 'yuguang',
        getName: function(){
            console.log(this === obj);
            console.log(this.a);
        }
    };
    
    obj.getName(); // true yuguang
    

    2、作为普通函数调用

    当函数不作为对象的属性被调用,而是以普通函数的方式,this总是指向全局对象(在浏览器中,通常是Window对象)

    window.name = 'yuguang';
    
    var getName = function(){
        console.log(this.name);
    };
    
    getName(); // yuguang
    

    或者下面这段迷惑性的代码:

    window.name = '老王'
    var obj = {
        name: 'yuguang',
        getName: function(){
            console.log(this.name);
        }
    };
    
    var getNew = obj.getName;
    getNew(); // 老王
    

    而在ES5的严格模式下,this被规定为不会指向全局对象,而是undefined

    3、构造器调用

    除了一些内置函数,大部分Js中的函数都可以成为构造器,它们与普通函数没什么不同

    构造器普通函数的区别在于被调用的方式
    当new运算符调用函数时,总是返回一个对象,this通常也指向这个对象

    var MyClass = function(){
        this.name = 'yuguang';
    }
    var obj = new MyClass();
    obj.name; // yuguang
    

    但是,如果显式的返回了一个object对象,那么此次运算结果最终会返回这个对象。

    var MyClass = function () {
        this.name = 1;
        return {
            name: 2
        }
    }
    var myClass = new MyClass(); 
    console.log('myClass:', myClass); // { name: 2}
    

    只要构造器不显示的返回任何数据,或者返回非对象类型的数据,就不会造成上述问题。

    4、call或apply调用

    跟普通的函数调用相比,用call和apply可以动态的改变函数的this

    var obj1 = {
        name: 1,
        getName: function (num = '') {
            return this.name + num;
        }
    };
    
    var obj2 = {
        name: 2,
    };
    // 可以理解成在 obj2的作用域下调用了 obj1.getName()函数
    console.log(obj1.getName()); // 1
    console.log(obj1.getName.call(obj2, 2)); // 2 + 2 = 4
    console.log(obj1.getName.apply(obj2, [2])); // 2 + 2 = 4
    

    5.箭头函数

    箭头函数不会创建自己的this,它只会从自己的作用域链的上一层继承this。

    因此,在下面的代码中,传递给getVal函数内的this并不是调用者自身,而是外部的this~

    this.val = 2;
    var obj = {
        val: 1,
        getVal: () => {
            console.log(this.val);
        }
    }
    
    obj.getVal(); // 2
    

    常见的坑

    就像标题一样,有的时候this会指向undefined

    情况一

    var obj = {
        name: '1',
        getName: function (params) {
            console.log(this.name)
        }
    };
    obj.getName();
    
    var getName2 = obj.getName;
    getName2();
    

    这个时候,getName2()作为普通函数被调用时,this指向全局对象——window。

    情况二

    当我们希望自己封装Dom方法,来精简代码时:

    var getDomById = function (id) {
        return document.getElementById(id);
    };
    getDomById('div1') //dom节点
    

    那么我们看看这么写行不行?

    var getDomById = document.getElementById
    getDomById('div1') // Uncaught TypeError: Illegal invocation(非法调用)
    

    这是因为:

    • 当我们去调用document对象的方法时,方法内的this指向document
    • 当我们用getId应用document内的方法,再以普通函数的方式调用,函数内容的this就指向了全局对象。

    利用call和apply修正情况二

    document.getElementById = (function (func) {
        return function(){
            return func.call(document, ...arguments)
        }
    })(document.getElementById) 
    // 利用立即执行函数将document保存在作用域中
    

    二、call和apply

    不要因为它的“强大”而对它产生抗拒,了解并熟悉它是我们必须要做的,共勉!

    思维导图

    在这里插入图片描述

    1.call和apply区别

    先来看区别,是因为它们几乎没有区别,下文代码实例call和apply都可以轻易的切换。

    当它们被设计出来时要做到的事情一摸一样,唯一的区别就在于传参的格式不一样

    • apply接受两个参数
      • 第一个参数指定了函数体内this对象的指向
      • 第二个参数为一个带下标的参数集合(可以是数组或者类数组)
    • call接受的参数不固定
      • 第一个参数指定了函数体内this对象的指向
      • 第二个参数及以后为函数调用的参数

    因为在所有(非箭头)函数中都可以通过arguments对象在函数中引用函数的参数。此对象包含传递给函数的每个参数,它本身就是一个类数组,我们apply在实际使用中更常见一些。

    call是包装在apply上面的语法糖,如果我们明确的知道参数数量,并且希望展示它们,可以使用call。

    当使用call或者apply的时候,如果我们传入的第一个参数为null,函数体内的this会默认指向宿主对象,在浏览器中则是window

    借用其他对象的方法

    我们可以直接传null来代替任意对象

    Math.max.apply(null, [1, 2, 3, 4, 5])
    

    2.call和apply能做什么?

    使用一个指定的 this 值和单独给出的一个或多个参数来调用一个函数——来时MDN

    • 调用构造函数来实现继承;
    • 调用函数并且指定上下文的 this;
    • 调用函数并且不指定第一个参数;

    1.调用构造函数来实现继承

    通过“借用”的方式来达到继承的效果:

    function Product(name, price) {
    	this.name = name;
    	this.price = price;
    }
    
    function Food(name, price) {
    	Product.call(this, name, price); //
    	this.category = food;
    }
    
    var hotDog = new Food('hotDog', 20);
    

    2.调用函数并且指定上下文的 this

    此时this被指向了obj

    function showName() {
        console.log(this.id + ':' + this.name);
    };
    
    var obj = {
        id: 1,
        name: 'yuguang'
    };
    
    showName.call(obj)
    

    3.使用call单纯的调用某个函数

    Math.max.apply(null, [1,2,3,10,4,5]); // 10
    

    三、模拟实现一个call

    先来看一下call帮我们需要做什么?

    var foo = {
    	value: 1
    };
    function show() {
    	console.log(this.value);
    };
    show.call(foo); //1
    

    就像解方程,要在已知条件中寻找突破哦口:

    • call 使得this的指向变了,指向了foo;
    • show 函数被执行了;
    • 传入的参数应为 this + 参数列表;

    第一版代码

    上面提到的3点,仅仅完成了一点,且传入的参数

    var foo = {
        value: 1
    };
    function show() {
        console.log(this.value);
    };
    Function.prototype.setCall = function (obj) {
        console.log(this); // 此时this指向show
        obj.func = this; // 将函数变成对象的内部属性
        obj.func(obj.value); // 指定函数
        delete obj.func // 删除函数,当做什么都没发生~
    }
    show.setCall(foo);
    

    第二版代码

    为了解决参数的问题,我们要能获取到参数,并且正确的传入:

    var foo = {
        value: 1
    };
    function show(a, b) {
        console.log(this.value);
        console.log(a + b);
    };
    Function.prototype.setCall = function (obj) {
        obj.fn = this; // 将函数变成对象的内部属性
        var args = [];
        for(let i = 1; i < arguments.length; i++){
            args.push('arguments[' + i + ']');
        }
        eval('obj.fn(' + args + ')'); // 传入参数
        delete obj.fn; // 删除函数,当做什么都没发生~
    }
    
    show.setCall(foo, 1, 2); // 1 3
    

    此时,我们就可以做到,传入多个参数的情况下使用call了,但是如果你仅想用某个方法呢?

    第三版代码

    Function.prototype.setCall = function (obj) {
        var obj = obj || window;
        obj.fn = this;
        var args = [];
        for(var i = 1, len = arguments.length; i < len; i++) {
        	args.push('arguments[' + i + ']');
      	}
      	var result = eval('obj.fn(' + args +')');
      	delete obj.fn;
      	return result;
    };
    // 测试一下
    var value = 2;
    var obj = { value: 1 };
    
    function bar(name, age) {
      	console.log(this.value);
      	return {
        	value: this.value,
        	name: name,
        	age: age
      	}
    }
    bar.setCall(null); // 2
    console.log(bar.setCall(obj, 'yuguang', 18));
    

    四、bind

    bind() 方法创建一个新的函数,在 bind() 被调用时,这个新函数的 this 被指定为 bind() 的第一个参数,而其余参数将作为新函数的参数,供调用时使用 —— MDN

    提到了callapply,就绕不开bind。我们试着来模拟一个bind方法,以便加深我们的认识:

    Function.prototype.bind = function (obj) {
        var _this = this; // 保存调用bind的函数
        var obj = obj || window; // 确定被指向的this,如果obj为空,执行作用域的this就需要顶上喽
        return function(){
            return _this.apply(obj, arguments); // 修正this的指向
        }
    };
    
    var obj = {
        name: 1,
        getName: function(){
            console.log(this.name)
        }
    };
    
    var func = function(){
        console.log(this.name);
    }.bind(obj);
    
    func(); // 1
    

    这样看上去,返回一个原函数的拷贝,并拥有指定的 this 值,还是挺靠谱的哦~

    写在最后

    JavaScript内功基础部分第一篇,总结这个系列是受到了冴羽大大的鼓励和启发,本系列大约会有15篇文章,都是我们在面试最高频的,但在工作中常常被忽略的。

    热门开源-欢迎star支持

    关于我

    • 花名:余光
    • Writing Vue and JavaScript
    • Working at GaoDing Design
    • A console log tester

    如果您看到了最后,不妨收藏、点赞、评论一下吧!!!
    持续更新,您的三连就是我最大的动力,虚心接受大佬们的批评和指点,共勉!

    展开全文
  • 起初以为this和$(this)就是一模子刻出来。但是我在阅读时,和coding时发现,总不是一回事。 view plain print ? &lt;!
    原文地址为:
    jQuery选择器this通过onclick传入方法以及Jquery中的this与$(this)初探,this传处变量等
    

    起初以为this和$(this)就是一模子刻出来。但是我在阅读时,和coding时发现,总不是一回事。

    1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
    2. <html xmlns="http://www.w3.org/1999/xhtml" lang="zh-cn">  
    3. <head>  
    4. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />  
    5.   
    6. <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>  
    7. <script>!window.jQuery && document.write('<script src="js/jquery-1.4.2.min.js"><\/script>')  
    8. </script>  
    9. <script type="text/javascript">  
    10. $(document).ready(function(){  
    11. $("span").click(function(){  
    12. alert($(this).html()); //把DOM的this对象包装成jq对象  
    13. });  
    14.   
    15. });  
    16.   
    17. </script>  
    18. </head>  
    19. <body>  
    20. <span>aaa</span>  
    21. <span>bbb</span>  
    22. <span>ccc</span>  
    23. <span>ddd</span>  
    24. <select name="btn" id="btn" >  
    25. <option value="1">日志标题</option>  
    26. <option value="2">日志全文</option>  
    27. <option value="3">评论引用</option>  
    28. <option value="4">所有留言</option>  
    29. <option value="5">页面搜索</option>  
    30. </select>  
    31. <script type="text/javascript">  
    32. $("#btn").bind("click",function(){  
    33.     alert($(this).val());  
    34. })  
    35.   
    36. $("#btn").click(function(){  
    37. alert($(this).html()); //把DOM的this对象包装成jq对象  
    38. });  
    39. </script>  
    40. </body>  



    http://neatstudio.com/show-833-1.shtml



    javascript中onclick(this) 中的this指当前什么东西?
    this就是当前标签本身
    οnclick=xxx(this)表示一个单击事件,来进行调用xxx(this)这个JavaScript函数。而xxx(this)函数中的this表示你要进行单击对象的本身。

    把this当做参数传到函数中去,实践Ok:

    1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
    2. <html xmlns="http://www.w3.org/1999/xhtml" lang="zh-cn">  
    3. <head>  
    4. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />  
    5.   
    6. <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>  
    7. <script>!window.jQuery && document.write('<script src="js/jquery-1.4.2.min.js"><\/script>')  
    8. </script>  
    9. <button id="12" οnclick="test(this)" name="button">ccc</button>   
    10. <script type="text/javascript">    
    11. function test(which){  
    12.          //which这个参数不要写成this  
    13.   alert($(which).attr("id"));  
    14.   
    15. }  
    16. </script>    
    17. </body>  





    于是最上面那个可以用onclick事件来传入到函数中,并用juqury来进行操作,如下实践Ok:

    1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
    2. <html xmlns="http://www.w3.org/1999/xhtml" lang="zh-cn">  
    3. <head>  
    4. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />  
    5. <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>  
    6. <script>!window.jQuery && document.write('<script src="js/jquery-1.4.2.min.js"><\/script>')  
    7. </script>  
    8.   
    9. </head>  
    10. <body>  
    11. <select name="btn" id="btn" οnclick=thisTestJquery(this)>  
    12. <option value="1">日志标题</option>  
    13. <option value="2">日志全文</option>  
    14. <option value="3">评论引用</option>  
    15. <option value="4">所有留言</option>  
    16. <option value="5">页面搜索</option>  
    17. </select>  
    18. <script type="text/javascript">  
    19. function thisTestJquery(th) {  
    20.     //th 这个参数不要写成this  
    21.     alert($(th).html());    
    22.     alert($(th).val());    
    23.     //两种获取ID的方法  
    24.     console.log(th.id);  
    25.     console.log($(th).attr("id"));  
    26.   
    27. }  
    28. </script>  
    29. </body>  



    点击后,结果如下:

    1. alert($(th).html());    


    结果:
    <option value="1">日志标题</option>
    <option value="2">日志全文</option>
    <option value="3">评论引用</option>
    <option value="4">所有留言</option>
    <option value="5">页面搜索</option>

    1. alert($(th).val());    


    结果:1

    而两种this获取Id值是这样的,实践也OK,如下:

    1. console.log(th.id);  
    2. console.log($(th).attr("id"));  





    对于多个id的按钮下进行click时,查找是哪个id值被点了,如下,但是有发ajax后,就不能在ajax里去写this了,那就是ajax那个this了,只能传入,如下所示:

    1. $("#exeall,#exe32,#exe64").click(function(){  
    2.   para.type = this.id.substr(3);//这样取是Ok的:this.id  
    3.   console.log($(this).id);//不能取到想要的Id  
    4.   console.log(this.id);//日志打印出来Ok  
    5.   var selfObj = this;//这样做才能传入到get里去。  
    6.   $.get("/php/cgi/execGray.php",para,function(data){  
    7.     self.done = false;  
    8.     var obj = eval('('+data+')');  
    9.     if(obj.code == -2)  
    10.     {  
    11.        console.log(selfObj.id);  
    12.     }  
    13.   }  
    14.   })  





    通过this传入变量
    在<a 中实现Js函数的this调用:

      1. <a href="javascript:void(0);" οnclick="modifyRequest(this)" data=\''+JSON.encode(requestObj)+'\'>' + requestObj.f_RequestCode + '</a> 
      2. 函数原型: 
      3.  function modifyRequest(obj){ 
      4.    var requestData = eval('('+$(obj).attr('data')+')');  
      5.   ......  


    转载请注明本文地址: jQuery选择器this通过onclick传入方法以及Jquery中的this与$(this)初探,this传处变量等
    展开全文
  • js中this到底指向谁

    千次阅读 多人点赞 2019-06-12 22:58:53
    什么是this JavaScript中的this是什么? 定义:this是包含它的函数作为方法被调用时所属的对象。 function fn1(){ this.name = &amp;amp;amp;amp;quot;halo&amp;amp;amp;amp;quot;; } fn1(); ...

    什么是this

    JavaScript中的this是什么?
    定义:this是包含它的函数作为方法被调用时所属的对象。

    function fn1(){
    	this.name = "halo";
    }
    fn1();
    
    • 我们将定义拆分一下
      • 包含它的函数:包含this的函数是fn1。
      • 作为方法被调用:fn1(); 此处fn1函数被调用。
      • 所属的对象:函数式调用函数默认所属的对象是window。

    通过上面三点分析,很容易知道fn1函数里的this指向的是window。
    那么如果是更复杂的场景我们如何判断this的指向呢?


    this到底指向谁

    如果想用一句话总结this的指向,稍微了解一些this指向的人都能脱口而出

    谁调用它,this就指向谁。
    

    也就是说this的指向是在调用时确定的,而不是在定义时确定的。这么说没有错,但是并不全面。
    其实,调用函数会创建新的术语函数自身的执行上下文。执行上下文的调用创建阶段会决定this的指向。所以更加准确的总结应该是:

    this的指向,是在调用函数时根据执行上下文所动态确定的。
    

    在es6箭头函数之前,想要判断一个函数内部this指向谁,就根据以下四种方式来决定的。

    1. 函数式调用
    2. 上下文对象调用
    3. 构造函数调用
    4. bind、call、apply改变this指向

    1、函数式调用

    先来看一种相对简单的情况,函数在全局环境中被直接调用,严格模式下函数内this指向undefined,非严格模式下函数内this指向window。如下

    function fn1() {
    	console.log(this)
    }
    
    function fn2() {
    	'use strict'
    	console.log(this)
    }
    
    fn1() // window
    fn2() // undefined
    

    再看下面例子:

    const age = 18;
    const p = {
         age:15,
         say:function(){
         	 console.log(this)
             console.log(this.age)
         }
    }
    var s1 = p.say
    s1()       
    

    这里say方法内的this仍然指向window,因为p中的say函数赋值给s1后,s1的执行仍然是在window的全局环境中。因此上面的代码最后输出windowundefined

    这里可能有人会有疑问,如果是在全局环境中,那this.age不是应该输出18么?这是因为使用const声明的变量不会挂载到window全局对象上,因此this指向window时找不到window上的age。换成var声明即可输出18.

    如果想让代码输出p中的age,并且让say函数中的this指向对象p。只需要改变函数的调用方式,如下

    const age = 18;
    const p = {
        age:15,
        say:function(){
        	console.log(this)
            console.log(this.age)
        }
    }
    p.say()
    

    输出

    	{age: 15, say: ƒ}
    	15
    

    因为此刻say函数内部的this指向的是最后调用它的对象。再次验证了那句话,this的指向,是在调用函数时根据执行上下文所动态确定的。

    2、上下文对象调用

    const p = {
    	age: 18,
    	fn: function() {
    		return this
    	}
    }
    
    console.log(p.fn() === p)
    

    输出

    true
    

    如果第一节的函数式调用理解了。那么这里应该也不会有疑问。
    我们再重复一遍this的指向,是在调用函数时根据执行上下文所动态确定的。
    记住这句话后遇到更复杂的场景也可以很容易的确定this指向。
    如下:

    const p = {
        age: 20,
        child: {
            age: 18,
            fn: function() {
                return this.age
            }
        }
    }
    console.log(p.child.fn())
    

    不论浅套关系如何变化,this都只想最后调用它的对象,因此输出18。
    再升级下代码:

    const o1 = {
        text: 'o1',
        fn: function() {
            return this.text
        }
    }
    const o2 = {
        text: 'o2',
        fn: function() {
            return o1.fn()
        }
    }
    const o3 = {
        text: 'o3',
        fn: function() {
            var fn = o1.fn
            return fn()
        }
    }
    
    console.log(o1.fn())
    console.log(o2.fn())
    console.log(o3.fn())
    

    输出结果

    o1
    o1
    undefined
    
    • 第一个,应该没有问题,直接找到调用this的那个函数。
    • 第二个,看似调用o2.fn(),其实内部调用的是o1.fn(),因此还是输出o1
    • 第三个,赋值后调用fn(),相当于在全局环境调用函数。this指向window
      如果现在的需求是想让
    console.log(o2.fn())
    

    输出o2,代码该如何修改?
    如下:

    const o1 = {
        text: 'o1',
        fn: function() {
            return this.text
        }
    }
    const o2 = {
        text: 'o2',
        fn: o1.fn
    }
    
    console.log(o2.fn())
    

    3、构造函数调用

    function Foo() {
        this.age = 18
    }
    const instance = new Foo()
    console.log(instance.age)
    

    输出18。知道输出结果并不难,但是new操作符调用构造函数时都做了什么呢?

    • 创建一个新对象;
    • 将构造函数的this指向这个新对象;
    • 为新对象添加属性、方法;
    • 返回新对象。

    需要注意的是,如果在构造函数中出现显式的return,那么就要分为两种场景分析。

    function Foo(){
        this.age = 18
        const o = {}
        return o
    }
    const instance = new Foo()
    console.log(instance.age)
    

    将会输出undefined,因为如果在构造函数中出现显式的return,并且返回一个对象时,那么创建的构造函数实例就是return返回的对象,这里instance就是返回的空对象o

    function Foo(){
        this.age = 18
        return 1
    }
    const instance = new Foo()
    console.log(instance.age)
    

    将会输出18,因为如果构造函数中出现显式return,但是返回一个非对象的值时,那么this还是指向实例。

    总结:当构造函数显式返回一个值,并且返回的是一个对象,那么this就指向这个返回的对象。如果返回的不是一个对象,this仍然指向实例。

    4、bind、call、apply改变this指向

    关于基础用法,这里不再赘述。需要知道的是bind/call/apply三者都是改变函数this指向的,call/apply是改变的同时直接进行函数调用,而bind只是改变this指向,并且返回一个新的函数,不会调用函数。callapply的区别就是参数格式不同。详见如下代码:

    const target = {}
    fn.call(target, 'arg1', 'arg2')
    

    上述代码等同于如下代码

    const target = {}
    fn.apply(target, ['arg1', 'arg2'])
    

    可以看出知识调用的参数形式不同而已,改写成bind如下所示

    const target = {}
    fn.bind(target, 'arg1', 'arg2')()
    

    不光要调用bind传入参数,还是在调用bind后再次执行函数。
    明白call/apply/bind的使用后,再来看一段代码:

    const foo = {
        age: 18,
        showAge: function() {
            console.log(this.age)
        }
    }
    const target = {
        age: 22
    }
    console.log(foo.showAge.call(target))
    

    结果输出22,只要掌握了call/apply/bind的基本用法,对于输出结果并不难理解。我们往往会遇到多种方式同时出现的情况,我们在说完箭头函数的this后会再详细说明this优先级相关内容。

    5、箭头函数this指向

    熟悉es6的人应该会知道箭头函数中的this指向,不再遵从上述的规制,而是根据外层的上下文来决定。
    es5代码:

    const foo = {  
        fn: function () {  
            setTimeout(function() {  
                console.log(this)
            })
        }  
    }  
    foo.fn()  // Window{……}
    

    this出现在setTimeout()中的匿名函数里时,this指向window对象。这种特性势必会给我们的开发带来一些坑,es6的箭头函数就很好的解决了这个问题。
    es6代码:

    const foo = {  
        fn: function () {  
            setTimeout(() => {  
                console.log(this)
            })
        }  
    } 
    foo.fn() // {fn: ƒ}
    

    箭头函数中的this指向,不再适用上面的标准,而是找到外层上下文,这段代码中this在箭头函数中,则找到外层的上下文的调用对象——foo。因此这里的this指向的就是foo

    注意:当箭头函数改变了this指向后,那么该this指向就不再受任何影响,也就是说不会再次发生改变,具体在this优先级章节中会举例说明。

    总结:

    • 通过call、apply、bind、new等改成this指向的操作称为显式绑定;
    • 根据上下文关系确定的this指向成为隐式绑定。

    如果一段代码中即出现显式绑定又有隐式绑定,该如何确定this指向呢?
    往下看

    6、this优先级

    function foo (age) {
        console.log(this.age)
    }
    
    const o1 = {
        age: 1,
        foo: foo
    }
    
    const o2 = {
        age: 2,
        foo: foo
    }
    
    o1.foo.call(o2)
    o2.foo.call(o1)
    

    如果隐式绑定优先级高于显式绑定,那么应该输出1,2。但是运行代码发现结果输出2,1。这也就说明了显式绑定中的call、apply优先级更高。
    再看:

    function foo (age) {
        this.age = age
    }
    
    const o1 = {}
    
    var fn = foo.bind(o1)
    fn(18)
    console.log(o1.age) // 18
    
    var f1 = new fn(22)
    console.log(f1.age); // 22
    

    分析下上面代码,fnfoo函数调用bind方法返回的函数,也就相当于是返回foo函数,并且将this指向o1对象。执行了fn(18)o1对象的age值就是18了,所以第一个输出结果是18。
    然后通过new调用fn函数,这时fn函数作为构造函数被调用,this就会指向返回的实例,从而与o1对象解绑。

    因此得出结论:new的优先级高于bind

    还记得上一节提到的箭头函数特行么?箭头函数影响的this指向无法被修改。看下面代码:

    function foo() {
        return () => {
            console.log(this.age)
        };
    }
    
    const o1 = {
        age: 2
    }
    
    const o2 = {
        age: 3
    }
    
    const fn = foo.call(o1)
    console.log(fn.call(o2))
    

    输出为2,foothis指向了o1fn接收的箭头函数的this自然也会指向o1而箭头函数的this是不会再次改变的,所以尽管用显式绑定call去改变this指向,也是不起作用的。


    结束啦!
    this涉及知识点繁多,碰到优先级问题也是让人头疼。
    没有什么捷径,唯有“死记硬背”+“慢慢理解”

    展开全文
  • 【java】this()与super()使用详解

    万次阅读 多人点赞 2018-01-10 16:36:20
    this调用属性、调用方法、利用this表示当前对象。 this this是自身的一个对象,代表对象本身,可以理解为:指向对象本身的一个指针。 this的用法在java中大体可以分为3种: 1.普通的直接引用 这种就...
  • 透彻理解并掌握JavaScript的this

    万次阅读 多人点赞 2018-01-04 17:24:34
    本文旨在透彻地阐述`this`。读完本文,就再也不用怕JavaScript中的`this`了。你将会知道在各种情况下怎么使用`this`,即使是最晦涩的用法也将不再是问题。
  • 在更新完pip的版本之后 使用pip继续安装django时报了这个错 WARNING: pip is being invoked ... This will fail in a future version of pip. Please see https://github.com/pypa/pip/issues/5599 for advice on f...
  • this关键字

    万次阅读 多人点赞 2019-03-20 12:39:33
    一、this关键字的意义 1、代表当前对象 2、this就是所在函数所属对象的引用,简单来说,哪个对象调用了this所在的函数,this就代表哪个对象 3、如下图,this代表的就是对象p,如右边内存图解,this会通过堆内存中...
  • 1、this关键字 package com.cj.study.thissuper; public class Student{ public String name; public void setName(String name) { this.name = name; } public String getName() { return name; }...
  • this关键字与super关键字详解

    万次阅读 多人点赞 2018-02-02 12:17:03
    一.this关键字 1.实例一: (1)需求:使用Java类描述一个动物; (2)实例: class Animal{ String name; //成员变量 String color; public Animal(String n,String c){ name = n; color = c; } ...
  • QT中this指针

    万次阅读 2017-08-01 20:58:12
    一:this指针只能在一个类的成员函数中调用,它表示当前对象的地址。下面是一个例子:  void Date::setMonth( int mn )  {  month = mn; // 这三句是等价的  this->month = mn;  (*this)....
  • 彻底搞懂 JS 中 this 机制

    万次阅读 多人点赞 2018-04-08 00:09:57
    彻底搞懂 JS 中 this 机制 摘要:本文属于原创,欢迎转载,转载请保留出处:https://github.com/jasonGeng88/blog 目录 this 是什么 this 的四种绑定规则 绑定规则的优先级 绑定例外 扩展:箭头函数 ...
  • this指向,防抖函数中的fn.apply(this,arguments)作用

    千次阅读 多人点赞 2019-12-11 11:29:51
    2.作用:都是用来改变this的指向的 3.下面介绍带参数和不带参数的常见的应用 首先想很好理解和应用apply,其根本是对于this的理解。 this的三种指向:1.指向this所在函数的直接调用者,2.new的时候,指向new出来的...
  • C++ this指针

    万次阅读 多人点赞 2019-06-07 21:13:37
    this 指针 引言: 首先,我们都知道类的成员函数可以访问类的数据(限定符只是限定于类外的一些操作,类内的一切对于成员函数来说都是透明的),那么成员函数如何知道哪个对象的数据成员要被操作呢,原因在于每个...
  • 1. 关于 this 2. this 全面解析 2.1 调用位置 2.2 绑定规则 2.2.1 默认绑定 2.2.2 隐式绑定 2.2.3 显式绑定 2.2.4 new 绑定 2.3 优先级 判断 this 2.4 箭头函数 3. 总结 本文基于你不知道的 ...
  • vue 中var _this=this作用

    万次阅读 多人点赞 2019-06-03 08:53:39
    var _this=this console.log(_this)原来的对象 console.log(this)//当前方法对象 _this只是一个变量名,this代表父函数,如果在子函数还用thisthis的指向就变成子函数了,_this就是用来存储指向的 ...
  • JS this指向总结

    万次阅读 多人点赞 2018-08-13 10:53:09
    使用 JavaScript 开发的时候,很多开发者多多少少会被 this 的指向搞蒙圈,但是实际上,关于 this 的指向,记住最核心的一句话:哪个对象调用函数,函数里面的this指向哪个对象。 下面分几种情况谈论下 1、普通...
  • 成功解决This DCH driver package is not compatible with the currently installed version of Windows. This system is configured to require a Standard driver package. The correct driver can be downloaded ...
  • Java中this关键字的详解

    万次阅读 多人点赞 2018-07-20 21:45:32
    在java的学习中,当接触到类这一章的时候,就会避免不了的接触到this关键字。 首先,this关键字指向的是当前对象的引用 作用: this.属性名称 指的是访问类中的成员变量,用来区分成员变量和局部变量(重名...
  • <!-- Unit.vue --> <!-- 左侧内容 --> ... ... fileId: this.id ...
  • js中var self=this的用法解释

    万次阅读 2018-09-25 17:11:54
    首先我们先来看一下,影响函数调用时this 绑定行为的new方法,如果想直接看var self=this的用法解释,请直接看二  一、影响函数调用时this 绑定行为的new方法  在讲解它之前我们首先需要澄清一个非常常见的关于...
  • C++中this与*this的区别

    万次阅读 多人点赞 2017-11-23 20:02:47
    别跟我说, return *this返回当前对象, return this返回当前对象的地址(指向当前对象的指针)。  正确答案为:return *this返回的是当前对象的克隆或者本身(若返回类型为A, 则是克隆, 若返回类型为A&, 则是...
  • data中定义了一个数据msg, vue实例上访问这个数据有两种方式,this.$data.msg 和 this.msg,请问,为vue如何实现this.msg能直接访问到data中的msg变量???data又为什么是个函数? 分析: clone 下 vue 的项目...
  • Vue中 let _this = this的作用

    万次阅读 2019-07-29 15:20:00
    在查看别人所写的代码时,通常都会看到这样的写法:let _this = this,一开始并不明白其用意,经过查阅发现其目的是为了存储this的指向。可以通过观察下面的例子来加深理解。 <!DOCTYPE html> <html> &...
  • this.$set的正确使用

    万次阅读 多人点赞 2019-09-19 14:29:27
    this.#set(obj, key, value) 我们在项目开发的过程中,经常会遇到这种情况:为data中的某一个对象添加一个属性 <template> <div class="hello"> <button @click="setMessage">添加属性</...
  • CTF What-is-this

    万次阅读 多人点赞 2020-10-01 00:21:02
    题目描述: 找到FLAG 题目附件: 附件1 1、附件1 ...提取码:82le 2、文件 3、把文件拷贝到kail Linux 4、tar -xvf e66ea8344f034964ba0b3cb9879996ff.gz ...5、拷贝到win—>用“Stegsolve”软件打开这两张图片 ...
  • Java之路:this关键字的用法

    万次阅读 多人点赞 2018-12-15 09:42:22
    (1)普通方法中,this总是指向调用该方法的对象。 (2)构造方法中,this总是指向正要初始化的对象。 (3)this可以让类中的一个方法,访问该类的另一个方法或属性。 (4)可以使用this关键字调用重载构造方法。...
  • $this $(this) this

    千次阅读 2018-05-30 18:57:13
    // this其实是一个Html 元素。 // $this 只是个变量名,加$是为说明其是个jquery对象。 ...// 而$(this)是个转换,将this表示的dom对象转为jquery对象,这样就可以使用jquery提供的方法操作。 ...
  • 在ES6中引入了类似其他语言类似写法, 即class(类),作为类对象...同时在JS里面this理解是一个难点和重点,那么在class中使用this将会是怎么一种场景呢?下面就对class中使用this进行剖析。 class的基本语法 ...
  • JS中的this是什么,this的四种用法

    千次阅读 2019-05-08 20:15:43
    在Javascript中,this这个关键字可以说是用的非常多,说他简单呢也很简单,说他难呢也很难,有的人开发两三年了,自己好像也说不清this到底是什么。下面我们来看看: 1、在一般函数方法中使用 this 指代全局对象 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,339,732
精华内容 3,335,892
关键字:

this