Es wird gesagt, dass JavaScript eine sehr flexible Sprache ist, aber tatsächlich kann man auch sagen, dass es eine verwirrende Sprache ist. Es kombiniert funktionale Programmierung und objektorientierte Programmierung mit dynamischen Sprachfunktionen und ist äußerst leistungsstark (tatsächlich kann es nicht mit C verglichen werden, ^_^).
Das Thema hier ist folgendes, gehen wir nicht zu weit. Dies selbst ist ursprünglich sehr einfach und zeigt immer auf die aktuelle Instanz der Klasse. Dieser kann kein Wert zugewiesen werden. Diese Prämisse besagt, dass dies nicht von der Klasse/dem Objekt getrennt werden kann, was bedeutet, dass dies ein häufiges Schlüsselwort in objektorientierten Sprachen ist. Um es im Extremfall auszudrücken: Wenn Sie JS mit einem funktionalen Stil anstelle eines objektorientierten Stils schreiben, wird dies in Ihrem gesamten Code viel weniger oder gar nicht vorhanden sein. Beachten Sie Folgendes: Wenn Sie dies verwenden, sollten Sie mit dem Objekt-/Klassen-Ansatz entwickeln, da dies sonst nur ein Nebeneffekt des Funktionsaufrufs ist.
dies in JS
Innerhalb der Funktion erstellt
Zeigt auf das Objekt, das beim Aufruf an die Funktion gebunden ist (ein Bissen)
Dies kann nicht zugeordnet werden, kann aber per Anruf/Bewerbung
Als ich das früher benutzte, war ich oft besorgt und unsicher. Du wusstest nicht, auf wen es hinwies? Hier ist eine Liste aller Einsatzorte
dies und Konstruktor
Dies und Objekt
Dies und Funktion
dies
der globalen Umwelt
this und DOM/events
Dies kann per Anruf/Bewerbung geändert werden
Neue Bindung und das
in ES5
ES6-Pfeilfunktion und das
1. Dies und Konstruktor
Dies selbst muss beim Definieren einer Klasse im Konstruktor verwendet werden, daher ist es selbstverständlich, mit dem Konstruktor zusammenzuarbeiten.
/**
* 页签
*
* @class Tab
* @param nav {string} 页签标题的class
* @param content {string} 页面内容的class
*
*/
function Tab(nav, content) {
this.nav = nav
this.content = content
}
Tab.prototype.getNav = function() {
return this.nav;
};
Tab.prototype.setNav = function(nav) {
this.nav = nav;
};
Tab.prototype.add = function() {
};
Gemäß der JavaScript-Konvention sollte dies an Attribute/Felder angehängt werden und Methoden sollten auf dem Prototyp platziert werden.
2. Dies und Objekte
Objekte in JS können ohne Klassen erstellt werden. Manche Leute werden überrascht sein, dass Klassen Vorlagen für Objekte sind und Objekte aus Vorlagen kopiert werden. JS tut dies, und Sie können Zehntausende Zeilen funktionalen Codes schreiben, ohne eine einzige Klasse zu schreiben. Übrigens spricht OOP von objektorientierter Programmierung, nicht von klassenorientierter Programmierung, richtig ^_^.
var tab = {
nav: '',
content: '',
getNav: function() {
return this.nav;
},
setNav: function(n) {
this.nav = n;
}
}
3. Dies und Funktion
Erstens macht es keinen Sinn, diese und unabhängige Funktionen zusammenzufassen. Wie bereits erwähnt, sollte dies objektorientiert sein. Eine reine Funktion ist lediglich eine Abstraktion, Kapselung und Wiederverwendung auf niedriger Ebene. Wie folgt
function showMsg() {
alert(this.message)
}
showMsg() // undefined
Definieren Sie showMsg und rufen Sie es dann als Funktion auf. this.message ist undefiniert. Daher ist es strengstens verboten, dies in reinen Funktionen zu verwenden, aber manchmal wird es so geschrieben und die aufrufende Methode ist call/apply
function showMsg() {
alert(this.message)
}
var m1 = {
message: '输入的电话号码不正确'
}
var m2 = {
message: '输入的身份证号不正确'
}
showMsg.call(m1) // '输入的电话号码不正确'
showMsg.call(m2) // '输入的身份证号不正确'
Auf diese Weise können Sie Code speichern, wenn beispielsweise zwei Klassen/Objekte ähnliche Methoden haben. Sie müssen nur eine Kopie definieren und diese dann an ihre jeweiligen Prototypen und Objekte binden . Zu diesem Zeitpunkt verwenden Sie tatsächlich noch Objekte oder Klassen (Methode 1/2), nur indirekt.
4. dies
der globalen UmweltWie bereits erwähnt, bedeutet dies: „Zeigen Sie auf das Objekt, das an die Funktion gebunden ist, wenn sie aufgerufen wird.“ Dieser Satz ist umständlich, aber absolut korrekt. Es gibt kein einziges redundantes Wort. In der globalen Umgebung gibt es verschiedene Hostobjekte. In der Browserumgebung handelt es sich um Fensterobjekte und in der Knotenumgebung um globale Objekte. Hier konzentrieren wir uns darauf in der Browserumgebung.
In der Browserumgebung zeigt dies innerhalb einer Nichtfunktion auf ein Fenster
alert(window=== this) // true
Daher werden Sie viele Open-Source-JS-Bibliotheken sehen, die so geschrieben sind
(function() {
// ...
})(dies);
Oder schreiben Sie so
(function() {
// ...
}).call(this);
Bei Unterstrichen und Requirejs besteht die allgemeine Idee beispielsweise darin, das globale Variablenfenster an die anonyme Funktion zu übergeben und zwischenzuspeichern, um einen direkten Zugriff zu vermeiden. Warum Caching erforderlich ist, hat etwas mit der JS-Bereichskette zu tun. Die Leistung beim Lesen der äußeren Kennung wird schlechter sein. Bitte überprüfen Sie die entsprechenden Kenntnisse selbst, sonst wäre es zu weit hergeholt.
In Browsern ist es ziemlich verwirrend, dass Variablen, die direkt mit var innerhalb von Nichtfunktionen deklariert werden, standardmäßig globale Variablen sind und standardmäßig als Attribute im Fenster hängen.
var andy = '刘德华' alert(andy === window.andy) // true alert(andy === this.andy) // true alert(window.andy === this.andy) // true
Aufgrund dieser Funktion sind einige schriftliche Testfragen wie
var x = 10;
function func() {
alert(this.x)
}
var obj = {
x: 20,
fn: function() {
alert(this.x)
}
}
var fn = obj.fn
func() // 10
fn() // 10
没错，最终输出的都是全局的 10。永远记住这一点：判断 this 指向谁，看执行时而非定义时，只要函数(function)没有绑定在对象上调用，它的 this 就是 window。
5. this 和 DOM/事件
W3C 把 DOM 实现成了各种节点，节点嵌套一起形成 DOM tree。节点有不同类型，如文本节点，元素节点等10多种。元素节点又分成了很多，对写HTML的人来说便是很熟悉的标签（Tag），如 div，ul，label 等。 看 W3C 的 API 文档，会发现它完全是按照面向对象方式实现的各种 API，有 interface，extends 等。如
看到了吧，这是用 Java 写的，既然是用面向对象方式实现的API，一定有类/对象（废话^_^），有 类/对象，则一定有 this （别忘了这篇文章的中心主题）。所有的 HTML tag 类命名如 HTMLXXXElement，如
HTMLDivElement
HTMLLabelElement
HTMLInputElement
...
前面说过 this 是指向当前类的实例对象，对于这些 tag 类来说，不看其源码也知它们的很多方法内部用到的 this 是指向自己的。 有了这个结论，写HTML和JS时， this 就清晰了很多。
示例A
<!-- this 指向 div --> <div onclick="alert(this)"></div>
示例B
<div id="nav"></div>
<script>
nav.onclick = function() {
alert(this) // 指向div#nav
}
</script>
示例C
$('#nav').on('click', function() {
alert(this) // 指向 nav
})
以上三个示例可以看到，在给元素节点添加事件的时候，其响应函数（handler）执行时的 this 都指向 Element 节点自身。jQuery 也保持了和标准一致，但却让人迷惑，按 “this 指向调用时所在函数所绑定的对象” 这个定义，jQuery 事件 handler 里的 this，应该指向 jQuery 对象，而非 DOM 节点。因此你会发现在用 jQuery 时，经常需要把事件 handler 里的 element 在用 $ 包裹下变成 jQuery 对象后再去操作。比如
$('#nav').on('click', function() {
var $el = $(this) // 再次转为 jQuery 对象，如果 this 直接为 jQuery 对象更好
$el.attr('data-x', x)
$el.attr('data-x', x)
})
有人可能有如下的疑问
<div id="nav" onclick="getId()">ddd</div>
<script>
function getId() {
alert(this.id)
}
</script>
点击 div 后，为什么 id 是 undefined，不说是指向的 当前元素 div 吗？ 如果记住了前面提到的一句话，就很清楚为啥是 undefined，把这句话再贴出来。
判断 this 指向谁，看执行时而非定义时，只要函数(function)没有绑定在对象上调用，它的 this 就是 window
这里函数 getId 调用时没有绑定在任何对象上，可以理解成这种结构
div.onclick = function() {
getId()
}
getId 所处匿名函数里的 this 是 div，但 getId 自身内的 this 则不是了。 当然 ES5 严格模式下还是有个坑。
6. this 可以被 call/apply 改变
call/apply 是函数调用的另外两种方式，两者的第一个参数都可以改变函数的上下文 this。call/apply 是 JS 里动态语言特性的表征。动态语言通俗的定义
程序在运行时可以改变其结构，新的函数可以被引进，已有的函数可以被删除，即程序在运行时可以发生结构上的变化
通常有以下几点特征表示它为动态语言
动态的数据类型
动态的函数执行
动态的方法重写
动态语言多从世界第二门语言 LISP 发展而来，如死去的 SmallTalk/VB，目前还活着的 Perl/Python， 以及还流行的 Ruby/JavaScript。JS 里动态数据类型的体现便是弱类型，执行的时候才去分析标识符的类型。函数动态执行体现为 eval，call/aply。方法重写则体现在原型重写。不扯远，这里重点说下 call/apply 对 this 的影响。
var m1 = {
message: 'This is A'
}
var m2 = {
message: 'This is B'
}
function showMsg() {
alert(this.message)
}
showMsg() // undefined
showMsg.call(m1) // 'This is A'
showMsg.call(m2) // 'This is B'
可以看到单独调用 showMsg 返回的是 undefined，只有将它绑定到具有 message 属性的对象上执行时才有意义。发挥想象力延伸下，如果把一些通用函数写好，可以任意绑定在多个类的原型上，这样动态的给类添加了一些方法，还节省了代码。这是一种强大的功能，也是动态语言的强表现力的体现。
经常会听到转向 Ruby 或 Python 的人提到“编程的乐趣”，这种乐趣是源自动态语言更接近人的思维（而不是机器思维），更符合业务流程而不是项目实现流程。同样一个功能，动态语言可以用更小的代码量来实现。动态语言对程序员生产力的提高，是其大行其道的主要原因。
性能方面，动态语言没有太大的优势，但动态语言的理念是：优化人的时间而不是机器的时间。提高开发者的生产力，宁肯牺牲部分的程序性能或者购买更高配置的硬件。随着IT业的不断发展和摩尔定律的作用，硬件相对于人件一直在贬值，这个理念便有了合理的现实基础。
JS 里的 call/apply 在任何一个流行的 lib 里都会用到，但几乎就是两个作用
配合写类工具实现OOP，如 mootools, ClassJS, class.js,
修复DOM事件里的 this，如 jQuery, events.js
关于 call 和 apply 复用：利用apply和arguments复用方法
关于 call 和 apply 的性能问题参考： 冗余换性能-从Backbone的triggerEvents说开了去
7. ES5 中新增的 bind 和 this
上面 6 里提到 call/apply 在 JS 里体现动态语言特性及动态语言的流行原因，其在 JS 用途如此广泛。ES5发布时将其采纳，提了一个更高级的方法 bind。
var modal = {
message: 'This is A'
}
function showMsg() {
alert(this.message)
}
var otherShowMsg = showMsg.bind(modal)
otherShowMsg() // 'This is A'
因为是ES5才加的，低版本的IE不支持，可以修复下Function.prototype。bind 只是 call/apply 的高级版，其它没什么特殊的。
8. ES6 箭头函数(arrow function) 和 this
ES6 在今年的 6月18日 正式发布（恰京东店庆日同一天，^_^），它带来的另一种类型的函数 - 箭头函数。箭头函数的一个重要特征就是颠覆了上面的一句话，再贴一次
判断 this 指向谁，看执行时而非定义时，只要函数(function)没有绑定在对象上调用，它的 this 就是 window
是的，前面一直用这句话来判断 this 的指向，在箭头函数里前面半句就失效了。箭头函数的特征就是，定义在哪，this 就指向那。即箭头函数定义在一个对象里，那箭头函数里的 this 就指向该对象。如下
var book = {
author: 'John Resig',
init: function() {
document.onclick = ev => {
alert(this.author) ; // 这里的 this 不是 document 了
}
}
};
book.init()
对象 book 里有一个属性 author， 有一个 init 方法， 给 document 添加了一个点击事件，如果是传统的函数，我们知道 this 指向应该是 document，但箭头函数会指向当前对象 book。
箭头函数让 JS 回归自然和简单，函数定义在哪它 this 就指向哪，定义在对象里它指向该对象，定义在类的原型上，指向该类的实例，这样更容易理解。
总结：
函数的上下文 this 是 JS 里不太好理解的，在于 JS 函数自身有多种用途。目的是实现各种语言范型（面向对象，函数式，动态）。this 本质是和面向对象联系的，和写类，对象关联一起的， 和“函数式”没有关系的。如果你采用过程式函数式开发，完全不会用到一个 this。 但在浏览器端开发时却无可避免的会用到 this，这是因为浏览器对象模型（DOM）本身采用面向对象方式开发，Tag 实现为一个个的类，类的方法自然会引用类的其它方法，引用方式必然是用 this。当你给DOM对象添加事件时，回调函数里引用该对象就只能用 this 了。
明白了么？
相信看完全文以后，this不再是坑～
