Drei JavaScript -Macken, die Java/C -Entwickler wissen sollten

Kernpunkte

• Im Gegensatz zu C oder Java ist JavaScripts Umfang funktionsbasiert und nicht blockbasiert; if for Erhöhung im JavaScript bedeutet, dass Variablen und Funktionserklärungen während der Zusammenstellung auf den oberen Rand ihres eingeschlossenen Umfangs verschoben werden, die Initialisierung jedoch nicht erhöht wird.
• Funktionen in JavaScript werden als erstklassige Bürger behandelt, was bedeutet, dass sie in Variablen gespeichert werden können, als Parameter übergeben, von anderen Funktionen zurückgegeben werden und Eigenschaften wie Objekte aufweisen.
• Die
-Antage (dynamische Umfangsvariable) in JavaScript wurde veraltet, da sie Laufzeitfehler verursachen und verwirrend ist.
• with JavaScript unterstützt Verschlüsse, sodass Funktionen nach der Rückkehr auf die Variablen der externen Funktionen zugreifen können, wodurch die Datenschutzdatenschutz verbessert und leistungsstarke Programmiermodi wie Module und private Variablen ermöglicht werden können.

JavaScript kann eine irreführende Sprache sein, sie kann schmerzhaft sein, da es nicht 100% konsistent ist. Es ist bekannt, dass es einige schlechte Teile von

<code class="language-css">table.sp_table {
  width: 100%;
  border-collapse: collapse;
  border-spacing: 0;
}
table.sp_table td, table.sp_table th {
  border: solid 1px #ccc;
  padding: 10px;
  line-height: 1.5;
  text-align: center;
  width: 20%;
}
table.sp_table tr td:first-child {
  font-weight: bold;
}</code>

verwirrenden oder redundanten Funktionen hat, die vermieden werden sollten: Die berüchtigten Aussagen, impliziten globalen Variablen und Vergleichsverhaltensausnahmen sind wahrscheinlich am berühmtesten. JavaScript ist einer der erfolgreichsten Flammengeneratoren in der Geschichte! Abgesehen von den Fehler, die es hat (teilweise in der neuen ECMascript -Spezifikation gelöst), hassen die meisten Programmierer JavaScript aus zwei Gründen: - Dom denken sie fälschlicherweise, dass es der JavaScript -Sprache entspricht, die eine sehr schlechte API hat. - Sie wechselten von Sprachen wie C und Java nach JavaScript. Die Syntax von JavaScript täuschte sie dazu, zu glauben, dass es genauso funktioniert wie diese imperativen Sprachen. Dieses Missverständnis kann zu Verwirrung, Frustration und Irrtum führen.

Deshalb hat JavaScript normalerweise einen schlechteren Ruf als es verdient. In meiner Karriere habe ich einige Muster bemerkt: Die meisten Entwickler mit Java- oder C/C -Hintergründen denken die gleichen Sprachmerkmale in JavaScript und sind völlig unterschiedlich. Dieser Artikel sammelt die problematischsten Sprachmerkmale und vergleicht Java -Ansätze mit JavaScript -Ansätzen, um Unterschiede zu zeigen und Best Practices in JavaScript hervorzuheben. with

Scope

Die meisten Entwickler beginnen JavaScript zu verwenden, weil sie dazu gezwungen sind, und fast alle Entwickler beginnen, Code zu schreiben, bevor sie Zeit damit verbringen, die Sprache zu lernen. Jeder solche Entwickler wurde mindestens einmal von JavaScript Scope täuscht. Da die Syntax von JavaScript der von C-Series (absichtlich) sehr ähnlich ist und die Funktionen der Funktionen trennen, wenn und für mit Zahnspangen, würden die Menschen vernünftigerweise erwarten, dass der Bereich der lexikalischen blockpegel Gibem wirbt. Leider ist dies nicht der Fall. Erstens wird in JavaScript der variable Umfang durch Funktionen und nicht durch Klammern bestimmt. Mit anderen Worten, wenn und für Körper keine neuen Bereiche erzeugen und Variablen, die in ihren Körpern deklariert sind, tatsächlich gefördert werden, d. H. Zu Beginn der innersten Funktion, die es deklariert, ansonsten globaler Umfang erstellt. Zweitens erzwingt die Existenz von with -Anserklärungen den JavaScript -Bereich, um dynamisch zu werden und erst zur Laufzeit zu ermitteln. Möglicherweise sind Sie nicht überrascht zu hören, dass die Verwendung von with Aussagen veraltet wurde: JavaScript ohne with wird tatsächlich eine lexikalische Scoped -Sprache sein, d. H. Der Umfang kann vollständig durch die Betrachtung des Codes bestimmt werden. In JavaScript gibt es vier Möglichkeiten, in den Umfang zu gelangen: - Sprachdefinition: Standardmäßig enthalten alle Bereiche Namen this und arguments. - Formale Parameter: Der Umfang eines (formalen) Parameters, der für eine Funktion deklariert ist, gehört zum Körper der Funktion. - Funktionserklärung. - Variable Deklaration.

Eine andere Komplexität wird durch den impliziten globalen Umfang der variablen Zuordnungen für (implizit) nicht im Schlüsselwort var nicht deklariert. Dieser Wahnsinn wird mit der impliziten Zuordnung des globalen Bereichs zu this Referenzen kombiniert, wenn eine Funktion ohne explizite Bindung aufgerufen wird (mehr im nächsten Abschnitt). Bevor Sie sich mit den Details befassen, können Sie klarstellen, welche guten Muster verwendet werden können, um Verwirrung zu vermeiden: Verwenden Sie strenge Muster ('use strict';) und verschieben Sie alle Variablen und Funktionserklärungen an die Oberseite jeder Funktion Innerhalb für und wenn Blöcke und Funktionen der Funktionen innerhalb dieser Blöcke (dies geht aus verschiedenen Gründen über den Rahmen dieses Artikels hinaus).

Höhe

Erhöhung ist eine vereinfachte Methode zur Erklärung des tatsächlichen Verhaltens von Aussagen. Die geförderte Variable wird zu Beginn der Funktion, die sie enthält, deklariert und in undefined initialisiert. Die Zuordnung findet dann in der tatsächlichen Zeile der ursprünglichen Erklärung statt. Bitte beachten Sie das folgende Beispiel:

<code class="language-css">table.sp_table {
  width: 100%;
  border-collapse: collapse;
  border-spacing: 0;
}
table.sp_table td, table.sp_table th {
  border: solid 1px #ccc;
  padding: 10px;
  line-height: 1.5;
  text-align: center;
  width: 20%;
}
table.sp_table tr td:first-child {
  font-weight: bold;
}</code>

Wie hoch ist der Wert, den Sie für die Konsole erwarten? Würden Sie von der folgenden Ausgabe überrascht sein?

<code class="language-css">table.sp_table {
  width: 100%;
  border-collapse: collapse;
  border-spacing: 0;
}
table.sp_table td, table.sp_table th {
  border: solid 1px #ccc;
  padding: 10px;
  line-height: 1.5;
  text-align: center;
  width: 20%;
}
table.sp_table tr td:first-child {
  font-weight: bold;
}</code>

Im if -Block deklariert die var -Anweisung keine lokale Kopie der Variablen i, sondern überschreibt die zuvor deklarierte Variable. Beachten Sie, dass die erste console.log Anweisung den tatsächlichen Wert der Variablen i druckt, der in undefined initialisiert wird. Sie können es testen, indem Sie die "use strict"; -Richtlinie als erste Zeile in der Funktion verwenden. Im strengen Modus müssen Variablen vor der Verwendung deklariert werden, aber Sie können überprüfen, ob die JavaScript -Engine aufgrund der Deklaration keine Fehler meldet. Bitte beachten Sie übrigens, dass Sie einen Fehler aufgrund der Neuklarierung var nicht melden: Wenn Sie solche Fehler aufnehmen möchten, sollten Sie einen Linter wie JSHINT oder JSINT besser verwenden, um Ihren Code zu verarbeiten. Schauen wir uns nun ein weiteres Beispiel an, um eine weitere fehleranfällige Verwendung von variablen Deklarationen hervorzuheben:

<code class="language-javascript">function myFunction() {
  console.log(i);
  var i = 0;
  console.log(i);
  if (true) {
    var i = 5;
    console.log(i);
  }
  console.log(i);
}</code>

Obwohl Sie möglicherweise anders erwarten, wird der if Körper ausgeführt, da eine lokale Kopie der Variablen namens test() in der Funktion notNull deklariert wird und durch gefördert wird. Geben Sie auch hier obligatorische Arbeiten ein.

Funktionserklärung und Funktionsausdruck

Erhöhung gilt nicht nur für Variablen, sondern auch

Funktionsausdrücke (es handelt sich tatsächlich um Variablen) und Funktionsdeklarationen werden auch gefördert. Dieses Thema muss sorgfältiger behandelt werden als ich hier, aber in kurzer Zeit verhalten sich Funktionserklärungen in etwa den Funktionsausdrücken, außer dass ihre Erklärungen auf den Beginn ihres Geltungsbereichs verschoben werden. Betrachten Sie das folgende Beispiel, das das Verhalten der Funktionserklärung zeigt:

<code>undefined
0
5
5</code>

Vergleichen Sie dies nun mit dem folgenden Beispiel, das das Verhalten von Funktionsausdrücken zeigt:

<code class="language-javascript">var notNull = 1;
function test() {
  if (!notNull) {
    console.log("Null-ish, so far", notNull);
    for(var notNull = 10; notNull < 20; notNull++) {
      //..
    }
    console.log("Now it's not null", notNull);
  }
  console.log(notNull);
}</code>

Weitere Informationen finden Sie im Abschnitt "Referenzabschnitt", um diese Konzepte weiter zu verstehen.

mit

Das folgende Beispiel zeigt eine Situation, in der das Zielfernrohr nur zur Laufzeit bestimmt werden kann:

<code class="language-javascript">function foo() {
    // 函数声明
    function bar() {
        return 3;
    }
    return bar();

    // 此函数声明将被提升并覆盖之前的声明
    function bar() {
        return 8;
    }
}</code>

Wenn

ein Feld namens y hat, wird die Funktion x foo() zurückgegeben, andernfalls wird 123 zurückgegeben. Diese Codierungspraxis kann die Quelle von Laufzeitfehlern sein. Daher wird dringend empfohlen, die Anweisung y.x zu vermeiden. with

Ich freue mich: ecmascript 6

Die Spezifikation

ecmascript 6 fügt eine fünfte Methode hinzu, um Block-Level-Bereich hinzuzufügen: die

-Antage. Betrachten Sie den folgenden Code: let

<code class="language-javascript">function foo() {
    // 函数表达式
    var bar = function() {
        return 3;
    };
    return bar();

    // 变量 bar 已经存在，并且永远不会到达此代码
    var bar = function() {
        return 8;
    };
}</code>

In ECMascript 6 deklariert

im Körper von if let, um eine neue Variable lokal zum i -Block zu erstellen. Als nicht standardmäßige Alternative kann der if -Blocke wie folgt deklariert werden: let

<code class="language-javascript">function foo(y) {
  var x = 123;
  with(y) {
    return x;
  }
}</code>

im obigen Code existieren die Variablen

und i nur im Block. Zum Zeitpunkt des Schreibens ist die Unterstützung für j selbst für Chrome begrenzt. let

Umfangszusammenfassung

Die folgende Tabelle fasst den Umfang in verschiedenen Sprachen zusammen:

特性	Java	Python	JavaScript	警告
作用域	词法（块）	词法（函数、类或模块）	是	它与 Java 或 C 的工作方式大相径庭
块作用域	是	否	let 关键字（ES6）	再一次警告：这不是 Java！
提升	不可能！	否	是	仅提升变量和函数表达式的声明。对于函数声明，也会提升定义
函数	作为内置类型	是	是	回调/命令模式对象（或 Java 8 的 lambda）
动态创建	否	否	eval – Function 对象	eval 存在安全问题，Function 对象可能无法按预期工作
属性	否	否	可以具有属性	无法限制对函数属性的访问
闭包	弱化，只读，在匿名内部类中	弱化，只读，在嵌套的 def 中	是	内存泄漏

Funktion

Ein weiteres sehr missverstandenes Merkmal von JavaScript ist, dass Funktionen, insbesondere in imperativen Programmiersprachen wie Java, kein Konzept von Funktionen gibt. Tatsächlich ist JavaScript eine funktionale Programmiersprache. Nun, es ist keine reine funktionale Programmiersprache wie Haskell - es hat immer noch einen imperativen Stil und fördert die Veränderbarkeit, anstatt nur wie Scala zuzulassen. JavaScript kann jedoch als rein funktionelle Programmiersprache mit Funktionsaufrufen ohne Nebenwirkungen verwendet werden.

Erstklassige Bürger

Funktionen in JavaScript können wie jeder andere Typ behandelt werden, z. B. Zeichenfolge und Nummer: Sie können in Variablen gespeichert, als Parameter an Funktionen übergeben, durch Funktionen zurückgegeben und in einem Array gespeichert werden. Funktionen können auch Eigenschaften haben und dynamisch verändert werden, weil ...

Objekt

Eine sehr überraschende Tatsache für die meisten JavaScript -Neulinge ist, dass Funktionen tatsächlich Objekte sind. In JavaScript ist jede Funktion tatsächlich ein Funktionsobjekt. Funktionskonstruktor erstellt ein neues Funktionsobjekt:

<code class="language-css">table.sp_table {
  width: 100%;
  border-collapse: collapse;
  border-spacing: 0;
}
table.sp_table td, table.sp_table th {
  border: solid 1px #ccc;
  padding: 10px;
  line-height: 1.5;
  text-align: center;
  width: 20%;
}
table.sp_table tr td:first-child {
  font-weight: bold;
}</code>

Dies entspricht fast:

<code class="language-javascript">function myFunction() {
  console.log(i);
  var i = 0;
  console.log(i);
  if (true) {
    var i = 5;
    console.log(i);
  }
  console.log(i);
}</code>

Ich sage, sie sind fast äquivalent, da die Verwendung des Funktionskonstruktors weniger effizient ist, anonyme Funktionen erzeugt und keine Schließungen für ihren Erstellungskontext erzeugt. Funktionsobjekte werden immer im globalen Bereich erstellt. Funktion (die Art der Funktion) ist auf dem Objekt integriert. Dies ist leicht zu sehen, indem Sie jede von Ihnen deklarierende Funktion überprüfen:

<code>undefined
0
5
5</code>

Dies bedeutet, dass die Funktion Eigenschaften hat und hat. Einige davon werden Funktionen zur Erstellungszeit wie Namen oder Längen zugeordnet. Diese Eigenschaften geben den Namen und die Anzahl der Parameter in der Funktionsdefinition zurück. Betrachten Sie das folgende Beispiel:

<code class="language-javascript">var notNull = 1;
function test() {
  if (!notNull) {
    console.log("Null-ish, so far", notNull);
    for(var notNull = 10; notNull < 20; notNull++) {
      //..
    }
    console.log("Now it's not null", notNull);
  }
  console.log(notNull);
}</code>

Aber Sie können sogar neue Eigenschaften für jede Funktion selbst festlegen:

<code class="language-javascript">function foo() {
    // 函数声明
    function bar() {
        return 3;
    }
    return bar();

    // 此函数声明将被提升并覆盖之前的声明
    function bar() {
        return 8;
    }
}</code>

Funktionszusammenfassung

Die folgende Tabelle beschreibt Funktionen in Java, Python und JavaScript:

特性	Java	Python	JavaScript	警告
函数作为内置类型	lambda，Java 8	是	是	回调/命令模式对象（或 Java 8 的 lambda）
动态创建	否	否	eval – Function 对象	eval 存在安全问题，Function 对象可能无法按预期工作
属性	否	否	可以具有属性	无法限制对函数属性的访问

Schließen

Wenn ich gebeten würde, meine Lieblings -JavaScript -Funktion zu wählen, würde ich die Schließung ohne zu zögern auswählen. JavaScript ist die erste Mainstream -Programmiersprache, die Verschlüsse einführt. Wie Sie wissen, haben Java und Python seit langem die Versionen von Schließungen geschwächt, aus denen Sie nur (einige) Werte von geschlossenen Scopes lesen können. In Java bieten beispielsweise anonyme innere Klassen eine schließe Funktionalität mit bestimmten Einschränkungen. Zum Beispiel können die endgültigen lokalen Variablen nur in ihrem Bereich verwendet werden - genauer gesagt können ihre Werte gelesen werden. JavaScript ermöglicht den vollständigen Zugriff auf externe Scoped -Variablen und -Funktionen. Sie können bei Bedarf durch lokale Definitionen gelesen, geschrieben und sogar versteckt werden: Sie können Beispiele für alle diese Fälle im Abschnitt "Scope" sehen. Interessanter ist, dass die in der Schließung erstellte Funktion sich an die Umgebung erinnert, in der sie geschaffen wurde. Durch die Kombination von Schließungen und Funktionsnistungen können Sie externe Funktionen über interne Funktionen zurückgeben, ohne sie auszuführen. Darüber hinaus können Sie lokale Variablen externer Funktionen in der Schließung ihrer internen Funktionen dauern, auch wenn die Ausführung der Funktion, die sie erklärt, beendet ist. Dies ist eine sehr leistungsstarke Funktion, hat aber auch ihre Nachteile, da es eine häufige Ursache für Speicherlecks in JavaScript -Anwendungen ist. Einige Beispiele veranschaulichen diese Konzepte:

<code class="language-css">table.sp_table {
  width: 100%;
  border-collapse: collapse;
  border-spacing: 0;
}
table.sp_table td, table.sp_table th {
  border: solid 1px #ccc;
  padding: 10px;
  line-height: 1.5;
  text-align: center;
  width: 20%;
}
table.sp_table tr td:first-child {
  font-weight: bold;
}</code>

Die obige makeCounter() -Funktion erstellt und gibt eine andere Funktion zurück, die die von ihm erstellte Umgebung verfolgt. Obwohl die Ausführung von counter beendet ist, wenn die Variable makeCounter() zugewiesen wird, bleibt die lokale Variable i im Abschluss von displayCounter und kann daher in seinem Körper zugegriffen werden. Wenn wir erneut makeCounter ausführen möchten, wird ein neuer Verschluss erzeugt, bei dem der Eintrag für i unterschiedlich ist:

<code class="language-javascript">function myFunction() {
  console.log(i);
  var i = 0;
  console.log(i);
  if (true) {
    var i = 5;
    console.log(i);
  }
  console.log(i);
}</code>

Um es interessanter zu machen, können wir die Funktion makeCounter() aktualisieren, um einen Parameter zu akzeptieren:

<code>undefined
0
5
5</code>

externe Funktionsparameter werden ebenfalls im Verschluss gespeichert, sodass wir diesmal keine lokalen Variablen deklarieren müssen. Jeder Anruf makeCounter() erinnert sich an den anfänglichen Wert, den wir festgelegt haben, und zählen weiter. Verschlüsse sind für viele grundlegende JavaScript -Muster von wesentlicher Bedeutung: Namespaces, Module, private Variablen, Speicher sind nur die berühmtesten. Lassen Sie uns beispielsweise sehen, wie private Variablen für ein Objekt simulieren:

<code class="language-javascript">var notNull = 1;
function test() {
  if (!notNull) {
    console.log("Null-ish, so far", notNull);
    for(var notNull = 10; notNull < 20; notNull++) {
      //..
    }
    console.log("Now it's not null", notNull);
  }
  console.log(notNull);
}</code>

Verwenden dieses Musters und mit Verschluss können wir einen Wrapper für den Eigenschaftsnamen erstellen und unsere eigenen Setter und Getter verwenden. ES5 erleichtert dies viel einfacher, da Sie Objekte für ihre Eigenschaften mit Getters und Setter erstellen und den Zugriff auf die Eigenschaften selbst bei feinsten Getreide steuern können.

Zusammenfassung Schließen

Die folgende Tabelle beschreibt Schließungen in Java, Python und JavaScript:

特性	Java	Python	JavaScript	警告
闭包	弱化，只读，在匿名内部类中	弱化，只读，在嵌套的 def 中	是	内存泄漏
记忆化模式	必须使用共享对象	可以使用列表或字典	是	最好使用惰性求值
命名空间/模块模式	不需要	不需要	是
私有属性模式	不需要	不可能	是	可能令人困惑

Schlussfolgerung

In diesem Artikel stelle ich drei Merkmale von JavaScript ein, die von Entwicklern aus verschiedenen Sprachen, insbesondere Java und C. oft missverstanden werden, oft missverstanden werden. Insbesondere diskutieren wir Konzepte wie Umfang, Werbung, Funktionen und Schließungen. Wenn Sie sich mit diesen Themen befassen möchten, finden Sie hier eine Liste einiger Artikel, die Sie lesen können: - Umfang in JavaScript - Funktionserklärungen und Funktionsausdrücke - let Anweisungen und let Blöcke

FAQs über JavaScript -Funktionen (FAQ)

Was ist der Unterschied zwischen "==" und "===" in JavaScript?

In JavaScript "==" und "===" sind Vergleichsbetreiber, aber sie arbeiten anders. Der Operator "==" wird als loser Gleichstellungsoperator bezeichnet. Es wird vergleicht, ob die beiden Werte nach der Durchführung einer erforderlichen Typumwandlung gleich sind. Dies bedeutet, dass, wenn Sie eine Zahl mit einer Zeichenfolge mit einem numerischen Literal vergleichen, das wahr zurückgibt. Zum Beispiel wird "5" == 5 wahr zurückgegeben. Andererseits ist "===" ein strenger Gleichstellungsoperator. Es führt keine Typkonvertierung durch. Wenn die beiden Werttypen unterschiedlich sind, gibt es false zurück. Zum Beispiel wird "5" === 5 false zurückgegeben, weil einer eine Zeichenfolge und die andere eine Zahl ist.

Warum hat JavaScript sowohl null als auch undefiniert?

In JavaScript sind Null und Undefined spezielle Werte, die nicht existieren. Sie werden jedoch etwas anders verwendet. Undefiniert bedeutet, dass die Variable deklariert wurde, aber noch nicht zugewiesen wurde. Null hingegen ist ein Zuordnungswert, der keinen Wert oder kein Objekt angibt. Dies impliziert, dass der Wert der Variablen nicht existiert, während undefined bedeutet, dass die Variable selbst nicht existiert.

Was ist die Verbesserung im JavaScript?

Erhöhung ist ein Mechanismus in JavaScript, der Variablen und Funktionserklärungen an die Spitze des eingeschlossenen Umfangs während der Zusammenstellungsphase bewegt. Dies bedeutet, dass Sie Variablen und Funktionen verwenden können, bevor Sie sie deklarieren. Es ist jedoch zu beachten, dass nur Erklärungen gefördert und die Initialisierung nicht gefördert werden. Wenn die Variable nach der Verwendung deklariert und initialisiert wird, wird der Wert undefiniert.

Was ist der Unterschied zwischen globalen Variablen und lokalen Variablen in JavaScript?

In JavaScript können Variablen globale oder lokale Variablen sein. Globale Variablen sind Variablen, die außerhalb jeder Funktion deklariert sind, oder Variablen, die überhaupt mit dem Schlüsselwort "var" deklariert sind. Es kann aus jeder Funktion im Skript zugegriffen werden. Lokale Variablen hingegen sind Variablen, die in einer Funktion unter Verwendung des Schlüsselworts "var" deklariert sind. Es kann nur innerhalb der von ihm ausgelösten Funktionen zugegriffen werden.

Was ist das Schlüsselwort "dieses" in JavaScript?

Das Schlüsselwort "This" in JavaScript ist ein spezielles Schlüsselwort, das sich auf den Kontext des Aufrufens einer Funktion bezieht. Sein Wert hängt davon ab, wie die Funktion aufgerufen wird. In einer Methode bezieht sich "dies" auf das Eigentümerobjekt. Individuell bezieht sich "dies" auf ein globales Objekt. In einer Funktion bezieht sich "dies" auf ein globales Objekt. In einer Veranstaltung bezieht sich "dies" auf das Element, das das Ereignis erhält.

Was sind Schließungen in JavaScript?

Ein Verschluss in JavaScript ist eine Funktion, die auf seinen eigenen Bereich, den Umfang und den globalen Umfang externer Funktionen sowie die Zugriffsfunktionsparameter und -variablen zugreifen kann. Auf diese Weise kann die Funktion in der zurückgegebenen externen Funktion auf Variablen zugreifen, die Variablen im Speicher halten und Datenschutz- und Funktionsfabriken ermöglichen.

Was ist der Unterschied zwischen Funktionserklärungen und Funktionsausdrücken in JavaScript?

In JavaScript können Funktionen in vielerlei Hinsicht definiert werden, von denen zwei Funktionserklärungen und Funktionsausdrücke sind. Eine Funktionserklärung definiert eine benannte Funktion, und die Deklaration wird gefördert, sodass die Funktion vor dem Definieren verwendet werden kann. Ein Funktionsausdruck definiert eine Funktion in einem Ausdruck und wird nicht gefördert, was bedeutet, dass er nicht vor ihrer Definition verwendet werden kann.

Was ist der Unterschied zwischen "let", "var" und "const" in JavaScript?

"let", "var" und "const" werden alle verwendet, um Variablen in JavaScript zu deklarieren, aber sie haben unterschiedliche Umfangsregeln. "var" ist funktionsübergreifend, was bedeutet, dass es nur in den von ihm deklarierenden Funktionen verwendet werden kann. "Let" und "const" werden blockiert, was bedeutet, dass sie nur innerhalb der Blöcke verwendet werden können, die sie deklarieren. Der Unterschied zwischen "let" und "const" besteht darin, dass "let" es Ihnen ermöglicht, Variablen neu zuzuweisen, während "const" dies nicht tut.

Was ist der Unterschied zwischen Objekten und Arrays in JavaScript?

In JavaScript werden Objekte und Arrays verwendet, um Daten zu speichern, sie werden jedoch auf unterschiedliche Weise gespeichert. Ein Objekt ist eine Sammlung von Eigenschaften, bei denen jede Eigenschaft ein Schlüsselwertpaar ist. Ein Schlüssel ist ein Zeichenfolge und ein Wert kann jeder Datentyp sein. Ein Array ist eine spezielle Art von Objekt, die eine Liste von Elementen darstellt. Schlüssel sind numerische Indizes, und Werte können von jedem Datentyp sein.

Was ist der Unterschied zwischen Methoden und Funktionen in JavaScript?

In JavaScript ist eine Funktion ein Codeblock für eine bestimmte Aufgabe, und es handelt sich um eine separate Entität, die bei Bedarf verwendet werden kann. Andererseits ist eine Methode eine Funktion, die einem Objekt zugeordnet ist, oder mit anderen Worten, eine Methode ist eine Eigenschaft eines Objekts als Funktion. Methoden werden auf die gleiche Weise wie gewöhnliche Funktionen definiert, mit der Ausnahme, dass ihnen Werte als Attribute von Objekten zugewiesen werden müssen.

Das obige ist der detaillierte Inhalt vonDrei JavaScript -Macken, die Java/C -Entwickler wissen sollten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!