Erweiterte Front-End-Grundlagen (6): Beobachten Sie Funktionsaufrufstapel, Bereichsketten und Abschlüsse in Chrome-Entwicklertools

In der Front-End-Entwicklung gibt es eine sehr wichtige Fähigkeit namens Breakpoint-Debugging.

In den Entwicklertools von Chrome können wir durch Breakpoint-Debugging den Ausführungsprozess von JavaScript Schritt für Schritt sehr bequem beobachten und intuitiv den Funktionsaufrufstapel, die Bereichskette, das Variablenobjekt und den Abschluss wahrnehmen, wodurch sich wichtige Informationen ändern . Daher spielt das Debuggen von Haltepunkten eine sehr wichtige Rolle, um Codefehler schnell zu lokalisieren und den Ausführungsprozess des Codes schnell zu verstehen. Dies ist auch eine wesentliche fortgeschrittene Fähigkeit für unsere Front-End-Entwickler.

Wenn Sie natürlich nicht genug über diese Grundkonzepte von JavaScript wissen [Ausführungskontext, variable Objekte, Abschlüsse, dies usw.], kann es natürlich schwierig sein, das Breakpoint-Debugging gründlich zu beherrschen. Aber glücklicherweise habe ich in den vorherigen Artikeln einen detaillierten Überblick über diese Konzepte gegeben, sodass es für jeden relativ einfach sein sollte, diese Fähigkeit zu beherrschen.

Damit jeder dies und den Abschluss besser versteht und weil die Definition des Abschlusses im vorherigen Artikel etwas voreingenommen ist, werde ich in diesem Artikel Beispiele zum Thema Abschluss verwenden. Erfahren Sie mehr über das Debuggen von Haltepunkten damit jeder rechtzeitig Korrekturen vornehmen kann. Ich gebe hier meinen Fehler zu und habe alle in die Irre geführt.

---

1. Überprüfung der Grundkonzepte

Die Funktion Beim Aufruf der Ausführung wird ein Ausführungskontext für die aktuelle Funktion erstellt. Während der Erstellungsphase des Ausführungskontexts werden jeweils das variable Objekt, die Bereichskette, der Abschluss und dieser Zeiger bestimmt. Im Allgemeinen gibt es in einem JavaScript-Programm mehrere Funktionen, und die JavaScript-Engine verwendet einen Funktionsaufrufstapel, um die Aufrufreihenfolge dieser Funktionen zu verwalten. Die Aufrufreihenfolge des Funktionsaufrufstapels stimmt mit der Stapeldatenstruktur überein.

---

2. Lernen Sie die Breakpoint-Debugging-Tools kennen

Versuchen Sie, die neueste Version des Chrome-Browsers zu verwenden (ich bin nicht sicher, ob die alte Version, die Sie verwenden, mit meiner identisch ist), und rufen Sie die Entwicklertools des Chrome-Browsers auf.

Drei vertikale Punkte in der oberen rechten Ecke des Browsers –> Weitere Tools –> Entwicklertools –>

In meiner Demo habe ich den Code in app.js eingefügt und ihn in index.html eingeführt. Im Moment müssen wir uns nur auf den roten Pfeil im Screenshot konzentrieren. Oben ganz links befindet sich eine Reihe von Symbolen. Wir können die Ausführungsreihenfolge von Funktionen steuern, indem wir sie verwenden. Von links nach rechts sind dies:

● Skriptausführung fortsetzen/anhalten

Skriptausführung fortsetzen/anhalten

● Nächsten Funktionsaufruf überspringen
, die tatsächliche Leistung wird nicht erreicht Wenn die Funktion erreicht ist, führen Sie den nächsten Schritt aus. Wenn eine Funktion angetroffen wird, wird der nächste Schritt direkt ausgeführt, ohne dass die Funktion eingegeben werden muss.

● Schritt zum nächsten Funktionsaufruf
Schritt hinein, die tatsächliche Leistung besteht darin, dass der nächste Schritt ausgeführt wird, wenn die Funktion nicht angetroffen wird. Wenn eine Funktion angetroffen wird, wird der Funktionsausführungskontext eingegeben.

● Aktuelle Funktion verlassen
Aktuelle Funktion verlassen

● Haltepunkte deaktivieren
Haltepunkte deaktivieren

● Bei Ausnahmen nicht pausieren
Ausnahmeerfassung ohne Pause

Unter diesen sind Überqueren, Betreten und Herausspringen die drei Operationen, die ich am häufigsten verwende.

Der zweite rote Pfeil auf der linken Seite des obigen Bildes zeigt auf den Funktionsaufrufstapel (Call Stack). Hier werden die Änderungen im Aufrufstapel während der Ausführung des Codes angezeigt.

Der dritte rote Pfeil links zeigt auf die Scope-Kette (Scope), wo die Scope-Kette der aktuellen Funktion angezeigt wird. Dabei repräsentiert Local das aktuelle lokale Variablenobjekt und Closure den Abschluss in der aktuellen Bereichskette. Mit Hilfe der hier dargestellten Scope-Chain-Anzeige können wir in einem Beispiel intuitiv bestimmen, wer der Verschluss ist, was für ein tiefgreifendes Verständnis des Verschlusses sehr hilfreich ist.

---

3. Haltepunkteinstellungen

Im Anzeigecode Klicken Sie auf die Zeilennummer, um einen Haltepunkt festzulegen. Haltepunkteinstellungen weisen die folgenden Merkmale auf:

Haltepunkte können nicht in der Zeile festgelegt werden, in der eine separate Variable deklariert wird (wenn kein Wert zugewiesen wird) oder eine Funktion deklariert wird.

Nachdem ein Haltepunkt festgelegt und die Seite aktualisiert wurde, wird der JavaScript-Code ausgeführt, bis die Haltepunktposition angehalten wird. Anschließend können wir mit dem Debuggen mithilfe der oben eingeführten Vorgänge beginnen.

Wenn Sie mehrere Haltepunkte festlegen, bestimmt das Chrome-Tool automatisch, dass die Ausführung vom frühesten Haltepunkt aus gestartet wird, daher setze ich normalerweise nur einen Haltepunkt.

---

4. Beispiele

Als nächstes verwenden wir For Einige Beispiele: Lassen Sie uns das Breakpoint-Debugging-Tool verwenden, um zu sehen, wie sich unsere Demofunktion während der Ausführung verhält.

Bevor wir weiterlesen, können wir innehalten und darüber nachdenken: Wer ist in diesem Beispiel der Abschluss?

这是来自《你不知道的js》中的一个例子。由于在使用断点调试过程中，发现chrome浏览器理解的闭包与该例子中所理解的闭包不太一致，因此专门挑出来，供大家参考。我个人更加倾向于chrome中的理解。

● 第一步：设置断点，然后刷新页面。

● 第二步：点击上图红色箭头指向的按钮（step into），该按钮的作用会根据代码执行顺序，一步一步向下执行。在点击的过程中，我们要注意观察下方call stack 与 scope的变化，以及函数执行位置的变化。

一步一步执行，当函数执行到上例子中

我们可以看到，在chrome工具的理解中，由于在foo内部声明的baz函数在调用时访问了它的变量a，因此foo成为了闭包。这好像和我们学习到的知识不太一样。我们来看看在《你不知道的js》这本书中的例子中的理解。

书中的注释可以明显的看出，作者认为fn为闭包。即baz，这和chrome工具中明显是不一样的。

而在备受大家推崇的《JavaScript高级编程》一书中，是这样定义闭包。

这里chrome中理解的闭包，与我所阅读的这几本书中的理解的闭包不一样。具体这里我先不下结论，但是我心中更加偏向于相信chrome浏览器。

我们修改一下demo01中的例子，来看看一个非常有意思的变化。

// demo02
var fn;
var m = 20;
function foo() {
    var a = 2;
    function baz(a) { 
        console.log(a);
    }
    fn = baz; 
}
function bar() {
    fn(m); 
}

foo();
bar(); // 20

这个例子在demo01的基础上，我在baz函数中传入一个参数，并打印出来。在调用时，我将全局的变量m传入。输出结果变为20。在使用断点调试看看作用域链。

是不是结果有点意外，闭包没了，作用域链中没有包含foo了。我靠，跟我们理解的好像又有点不一样。所以通过这个对比，我们可以确定闭包的形成需要两个条件。

● 在函数内部创建新的函数；

● 新的函数在执行时，访问了函数的变量对象；

还有更有意思的。

我们继续来看看一个例子。

// demo03

function foo() {
    var a = 2;

    return function bar() {
        var b = 9;

        return function fn() {
            console.log(a);
        }
    }
}

var bar = foo();
var fn = bar();
fn();

在这个例子中，fn只访问了foo中的a变量，因此它的闭包只有foo。

修改一下demo03，我们在fn中也访问bar中b变量试试看。

// demo04

function foo() {
    var a = 2;

    return function bar() {
        var b = 9;

        return function fn() {
            console.log(a, b);
        }
    }
}

var bar = foo();
var fn = bar();
fn();

这个时候，闭包变成了两个。分别是bar，foo。

我们知道，闭包在模块中的应用非常重要。因此，我们来一个模块的例子，也用断点工具来观察一下。

// demo05
(function() {

    var a = 10;
    var b = 20;

    var test = {
        m: 20,
        add: function(x) {
            return a + x;
        },
        sum: function() {
            return a + b + this.m;
        },
        mark: function(k, j) {
            return k + j;
        }
    }

    window.test = test;

})();

test.add(100);
test.sum();
test.mark();

var _mark = test.mark();
_mark();

注意：这里的this指向显示为Object或者Window，大写开头，他们表示的是实例的构造函数，实际上this是指向的具体实例

上面的所有调用，最少都访问了自执行函数中的test变量，因此都能形成闭包。即使mark方法没有访问私有变量a，b。

我们还可以结合点断调试的方式，来理解那些困扰我们很久的this指向。随时观察this的指向，在实际开发调试中非常有用。

// demo06

var a = 10;
var obj = {
    a: 20
}

function fn () {
    console.log(this.a);
}

fn.call(obj); // 20

更多的例子，大家可以自行尝试，总之，学会了使用断点调试之后，我们就能够很轻松的了解一段代码的执行过程了。这对快速定位错误，快速了解他人的代码都有非常巨大的帮助。大家一定要动手实践，把它给学会。

Lassen Sie uns abschließend auf der Grundlage der obigen Erkundungssituation den Abschluss noch einmal zusammenfassen:

Die Erstellung des Abschlusses wird erst dann bestätigt, wenn die Funktion aufgerufen und ausgeführt wird.

Die Bildung von Abschlüssen steht in direktem Zusammenhang mit der Zugriffsreihenfolge der Scope-Kette.

Ein Abschluss wird nur gebildet, wenn die interne Funktion auf das Variablenobjekt in der oberen Bereichskette zugreift. Daher können wir Abschlüsse verwenden, um auf Variablen innerhalb der Funktion zuzugreifen.

Die in Chrome verstandenen Abschlüsse unterscheiden sich stark von den Abschlüssen, die in „JS You Don't Know“ und „JavaScript Advanced Programming“ verstanden werden. Ich persönlich bin eher geneigt, an Chrome zu glauben. Ich werde hier keine voreiligen Schlussfolgerungen ziehen. Sie können es selbst bestätigen, nachdem Sie es anhand meiner Ideen untersucht haben. In einem früheren Artikel habe ich eine Definition erstellt, die auf dem basiert, was ich aus dem Buch gelernt habe. Es tut mir leid.