JavaScript-Bereich in einem try-block

Sagen, dass ich versuche, führen Sie dieses JavaScript-snippet. Übernehmen die nicht deklarierten vars und Methoden deklariert sind, anderswo, oben, und dass something und somethingElse bewerten zu boolean-true.

try {
    if(something) {
        var magicVar = -1;
    }

    if(somethingElse) {
        magicFunction(magicVar);
    }
} catch(e) {
    doSomethingWithError(e);
}

Meine Frage ist: was ist der Umfang der magicVar und ist es okay, pass es in magicFunction wie ich es getan habe?

Es scheint mir, wie dieser gerade eine Frage über den Geltungsbereich von Variablen nicht Geltungsbereich von Variablen in einem try-block.

InformationsquelleAutor user5243421 | 2012-05-04

javascript scope

21

Javascript-Funktionsumfang. Das bedeutet, dass magicvar existieren wird, vom Anfang der Funktion deklariert werden, die in den ganzen Weg bis zum Ende der Funktion, auch wenn diese Aussage nicht immer ausführen. Dies wird als variable Hubgeschwindigkeit. Das gleiche passiert mit Funktionen-Deklarationen, die wiederum aufgerufen wird Funktion hochziehen.

Wenn die variable deklariert ist, in globalen Bereich, es wird sichtbar sein alles. Dies ist Teil der Grund, warum Globale Variablen werden als das böse in Javascript.

Deinem Beispiel passieren undefined in magicFunction wenn something ist falsch, weil magicVar noch nicht zugewiesen wurde, zu nichts.

Dies ist zwar technisch gültiges Javascript, ist es im Allgemeinen als schlechter Stil und wird nicht passieren-Stil-checker wie jsLint. Extrem unintuitiv Javascript wie diese ausführen, ohne jede Fehlermeldung
```
alert(a); //alerts "undefined"
var a;
```
POP QUIZ: Was macht der folgende code?
```
(function() {
  x = 2;
  var x;
  alert(x);
})();
alert(x);
```
- Das Beispiel, das Sie Gaben, ist nicht ganz gut, denn es war undefined sowieso, weil window.a ist undefined
- Ich bin mir nicht sicher, ich sehen, was Sie bekommen in. Wenn Sie nur versuchen zu laufen alert(a) alle von selbst, wird es werfen eine Fehlermeldung wie a is 'undefined'.
- Die Sache ist, dass a kann undefiniert, weil es undefiniert in outerscope. Werfen Sie einen Blick auf dieses demo, Wenn Sie entfernen die var x Sie immer noch das gleiche Ergebnis erhalten.
- Ich verstehe immer noch nicht was Sie bekommen haben, an. Mein Punkt ist, dass diesen code wird ohne Fehler ausgeführt, in der Erwägung, dass diesen code wirft einen Fehler.
- Alarm zwei werfen Sie dann einen Fehler? (wenn x nicht definiert in outerscope)
- Ja, das ist richtig.
- Ich meinte, zu Dingen, wie folgt. die Seite ist böse mit mir : avoid extended discussions in comments.
InformationsquelleAutor Peter Olson
32

Viele andere gute Antworten darüber, wie Javascript behandelt diese mit var, aber ich dachte, ich hätte die Adresse, die let situation...

Ob eine variable definiert ist, mit let innerhalb der try block, es wird NICHT im Geltungsbereich innerhalb der catch (oder finally) block(s). Es müsste definiert werden, in dem umschließenden block.

Beispielsweise in den folgenden code-block, der die Ausgabe in der Konsole wird "Außerhalb":
```
let xyz = "Outside";

try {
    let xyz = "Inside";

    throw new Error("Blah");
} catch (err) {
    console.log(xyz);
}
```
- Hmm, ein guter Grund für die Verwendung von " var " in diesem Fall in diesem Fall!
InformationsquelleAutor DrEnter
5
- In javascript-Funktionen erstellen Sie einen neuen Kontext -Verschluss.
- Jede definition einer Variablen ist eigentlich eine Deklaration der Variablen an der Spitze seines Umfangs und eine Zuweisung an der Stelle, wo die definition ist.
var
- Funktion Gültigkeitsbereich
- hissen an die Spitze seiner Funktion
- redeclarations mit dem gleichen Namen im gleichen Umfang sind keine-ops
Möchten Sie vielleicht zu Lesen MDN Umfang cheat sheet

Aufgrund hoisting können Sie auch tun, Dinge wie diese:
```
function bar() {
    var x = "outer";

    function foo() {
        alert(x); //{undefined} Doesn't refer to the outerscope x
        //Due the the var hoising next:        
        x = 'inner';
        var x;
        alert(x); //inner

    }
    foo();
}

bar();

bar();
```
Demo

Also die foo - Funktion umgewandelt wird, so etwas wie dieses:
```
function foo() {
    var x;
    alert(x); //{undefined} Doesn't refer to the outerscope x
    //Due the the var hoising next:        
    x = 'inner';
    alert(x); //inner
}
```
Meine Frage ist: was ist der Umfang der magicVar und ist es okay, pass es in magicFunction wie ich es getan habe?

Definieren okay..., ja der code ist gültig, aber es ist weniger lesbare dann, wenn die Variablen-Deklarationen waren auf der Oberseite, das ist alles.
- Ich bin hin und her gerissen! Ich Liebe beide Ihre und Peter Olson ist. Ein upvote 🙂
- Fühlen Sie sich nicht schlecht. Wählen Sie einfach die beste Antwort, die Sie denken, Sie haben. (Ich weiß nicht wie Stackoverflow Idee, die akzeptierten Antworten, erscheint an der Spitze {hörte ich hissen? :)}, es macht keinen Sinn, dass der Kerl die hat wahrscheinlich die weniger wissen über die Frage entscheiden, welche Antwort die beste ist.) Wenn es die Antwort des Petrus ich bin cool mit ihm, ich don ' T konkurrieren mit Antworten.
- Der Spickzettel link ist als veraltete Inhalte. Liebe die große Warnung-bars auf dieser Seite-Sie sind nicht gonna verpassen! haha
InformationsquelleAutor gdoron
3

Durch javascript "hochziehen" (google es), Ihre Deklaration von Variablen code wird übersetzt als:
```
function yourFunction() {
  var magicVar;
  try {
      if(something) {
          magicVar = -1;
      }

      if(somethingElse) {
          magicFunction(magicVar);
      }
  } catch(e) {
      doSomethingWithError(e);
  }

} //end of your function
```
"Hochziehen" bewegt alle Variablen-Deklarationen an den Anfang der Funktion. So magicVar ist verfügbar überall in der Funktion, aber es ist undefiniert, bis Sie ihm einen Wert.

Deine variable hat den Gültigkeitsbereich von Funktionen.

InformationsquelleAutor Marc
1

Mit var, Variablen existieren, die vom Anfang der Funktion bis Ende, egal, wo Sie deklariert sind, oder selbst wenn die Aussage eigentlich nie erreicht. Sie werden jedoch von den undefined bis Sie ein anderer Wert zugeteilt.

Also in deinem Fall, wenn something ist falsch, aber somethingelse ist wahr, Sie rufen magicFunction mit dem ersten argument wird undefined.

Den let Schlüsselwort Javascript erstellt 1.9 und verfügbar (Stand heute, Mai 3^rd 2012, und so weit ich weiß) nur in Firefox, deklariert Variablen mit dem Gültigkeitsbereich Semantik, die Sie wahrscheinlich gewöhnt sind.

InformationsquelleAutor zneak
0

Ich Stimme mit variabler Förder-und Funktion hochziehen, möchte ich betonen zwei Punkte importieren.
- Identifier, Definiert in der Catch-parameter ist, d.h. err/e(error) , bezieht sich auf Catch-block definiert.
- Funktion zuerst hochziehen.
  Beispiel :
```
    b(); //output : 3
    var b = 2;
    function b(){
     return 3;
    }
```
InformationsquelleAutor Nikhil_k

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.