var Funktionsname = function() {} vs Funktion functionName() {}

Hier ist die Verminderung auf die standard-Formulare erstellen Funktionen: (Ursprünglich geschrieben für eine andere Frage, aber angepasst, nachdem er zog in die kanonische Frage.)

Begriffe:

• ES5: ECMAScript 5th edition, 2009
• ES2015: ECMAScript 2015 (auch bekannt als "ES6")

Die quick-Liste:

• Funktion Erklärung

• "Anonymous" function Ausdruck (die trotz der Begriff, manchmal Funktionen erstellen, mit Namen)

• Namens function Ausdruck

• Accessor-Funktion-Initialisierung (5+)

• Pfeil Funktion Ausdruck (ES2015+) (die, wie anonyme Funktion Ausdrücken, nicht mit einem expliziten Namen, und doch können Funktionen erstellen, mit Namen)

• Methode Erklärung im Objekt-Initialisierer (ES2015+)

• Konstruktor und Methode Erklärungen in class (ES2015+)

Funktion Deklaration

Die erste form ist eine Funktion Erklärung, die wie folgt aussieht:

function x() {
    console.log('x');
}

Einer Funktionsdeklaration ist ein Erklärung; es ist nicht eine Anweisung oder ein Ausdruck. Als solche, die Sie nicht Folgen Sie es mit einem ; (obwohl dabei so harmlos ist).

Einer Funktionsdeklaration wird verarbeitet, wenn die Ausführung tritt der Kontext in dem es erscheint, vor jede Schritt-für-Schritt-code ausgeführt wird. Die Funktion, die es schafft, erhält einen richtigen Namen (x im Beispiel oben), und dieser name wird in dem Bereich, in dem die Erklärung erscheint.

Weil es verarbeitet, bevor eine Schritt-für-Schritt-code in dem gleichen Zusammenhang, die Sie tun können, Dinge wie diese:

x(); //Works even though it's above the declaration
function x() {
    console.log('x');
}

Bis ES2015, die spec nicht abdecken, was eine JavaScript-engine tun sollten, wenn Sie eine Funktion Deklaration innerhalb einer Kontrollstruktur wie try, if, switch, while usw., wie diese:

if (someCondition) {
    function foo() {    //<===== HERE THERE
    }                   //<===== BE DRAGONS
}

Und da sind Sie verarbeitet vor Schritt-für-Schritt-code ausgeführt wird, ist es schwierig zu wissen, was zu tun ist, wenn Sie sind in einer Kontroll-Struktur.

Obwohl dies zu tun war nicht angegeben bis ES2015, es war ein zulässige Erweiterung zur Unterstützung von Funktions-Deklarationen in Blöcken. Leider (und zwangsläufig), verschiedene Motoren haben verschiedene Dinge.

Als der ES2015, die Spezifikation sagt, was zu tun ist. In der Tat, es gibt drei verschiedene Dinge zu tun:

1. Wenn Sie in losen Modus nicht über einen web-browser, die JavaScript-engine soll um eine Sache zu tun
2. Wenn in lose-Modus in einem web-browser die JavaScript-engine soll etwas anderes tun,
3. Wenn in strengen - Modus (browser oder nicht), die JavaScript-engine soll das tun, noch eine andere Sache

Die Regeln für die lose-Modi sind schwierig, aber in strengen - Modus, Funktions-Deklarationen in Blöcken sind einfach: Sie sind lokal zu dem block (Sie haben Blockbereich, das ist auch neu in ES2015), und Sie sind gehisst an der Spitze des Blocks. Also:

"use strict";
if (someCondition) {
    foo();               //Works just fine
    function foo() {
    }
}
console.log(typeof foo); //"undefined" (`foo` is not in scope here
                         //because it's not in the same block)

"Anonymous" function Ausdruck

Die zweite häufigste form wird als anonymen Funktion der Ausdruck:

var y = function () {
    console.log('y');
};

Wie alle Ausdrücke, es bewertet, wenn es erreicht Sie in der Schritt-für-Schritt-Ausführung des Codes.

In ES5, die Funktion schafft dies hat keinen Namen (es ist anonym). In ES2015, die Funktion ist ein name zugeordnet, der, wenn möglich, von abzuleiten ist es aus dem Kontext. Im obigen Beispiel würde der name y. Etwas ähnliches geschieht, wenn die Funktion den Wert einer Eigenschaft Initialisierung. (Für details, wenn dies geschieht und die Regeln, Suche für SetFunctionName im die Spezifikation — es erscheint alle über Platz.)

Namens function Ausdruck

Die Dritte form ist eine benannten Funktions-Ausdruck ("NFE"):

var z = function w() {
    console.log('zw')
};

Dieser Funktion erstellt einen passenden Namen (w in diesem Fall). Wie alle Ausdrücke, diese wird ausgewertet, wenn es erreicht Sie in der Schritt-für-Schritt-Ausführung des Codes. Der name der Funktion ist nicht Hinzugefügt, um den Umfang, in dem der Ausdruck angezeigt wird; die Namen ist im Anwendungsbereich innerhalb der Funktion selbst:

var z = function w() {
    console.log(typeof w); //"function"
};
console.log(typeof w);     //"undefined"

Beachten Sie, dass NFEs haben Häufig eine Quelle von bugs für JavaScript-Implementierungen. IE8 und früher, zum Beispiel, Griff NFEs völlig falsch, die Schaffung von zwei unterschiedlichen Funktionen in zwei verschiedenen Zeiten. Frühen Safari-Versionen hatten Probleme. Die gute Nachricht ist, dass aktuelle Versionen von Browsern (IE9 und höher, aktuelle Safari) nicht haben diese Probleme nicht mehr. (Aber als dies geschrieben wurde, leider, IE8 bleibt weit verbreitet, und so mit NFEs mit code für das web im Allgemeinen immer noch problematisch ist.)

Accessor-Funktion-Initialisierung (5+)

Manchmal Funktionen kann schleichen in weitgehend unbeachtet; das ist der Fall mit - accessor-Funktionen. Hier ist ein Beispiel:

var obj = {
    value: 0,
    get f() {
        return this.value;
    },
    set f(v) {
        this.value = v;
    }
};
console.log(obj.f);         //0
console.log(typeof obj.f);  //"number"

Beachten Sie, dass, wenn ich die Funktion, die ich nicht verwenden ()! Das ist, weil es eine accessor-Funktion für eine Eigenschaft. Wir Holen Sie und legen Sie die Eigenschaft in der üblichen Weise, aber hinter den kulissen, die die Funktion aufgerufen wird.

Können Sie auch schaffen-accessor-Funktionen mit Object.defineProperty, Object.defineProperties, und die weniger bekannte zweite argument Object.create.

Pfeil Funktion Ausdruck (ES2015+)

ES2015 bringt uns die Pfeil-Funktion. Hier ein Beispiel:

var a = [1, 2, 3];
var b = a.map(n => n * 2);
console.log(b.join(", ")); //2, 4, 6

Sehen, dass n => n * 2 Sache, die sich in der map() nennen? Das ist eine Funktion.

Ein paar Dinge, über die Pfeil-Funktionen:

1. Haben Sie nicht Ihre eigenen this. Stattdessen werden Sie in der Nähe über die this von dem Kontext, in dem Sie definiert sind. (Sie schließen Sie auch über arguments - und, sofern relevant, die super.) Dies bedeutet, dass die this in Ihnen ist der gleiche wie der this wo Sie entstanden sind, und kann nicht geändert werden.

2. Wie Sie bemerkt haben werden mit den oben genannten, die Sie nicht verwenden das Schlüsselwort function; verwenden Sie stattdessen =>.

Den n => n * 2 Beispiel oben ist eine form von Ihnen. Wenn Sie mehrere Argumente übergeben werden der Funktion, die Sie verwenden, parens:

var a = [1, 2, 3];
var b = a.map((n, i) => n * i);
console.log(b.join(", ")); //0, 2, 6

(Denken Sie daran, dass Array#map übergibt den Eintrag als erstes argument, und der index als das zweite.)

In beiden Fällen, wird der Körper der Funktion ist ein Ausdruck, den Rückgabewert der Funktion wird automatisch das Ergebnis des Ausdrucks (Sie don ' T verwenden Sie eine explizite return).

Wenn du machst mehr als nur einen einzigen Ausdruck verwenden {} und eine explizite return (wenn Sie einen Rückgabewert hat), als normal:

var a = [
  {first: "Joe", last: "Bloggs"},
  {first: "Albert", last: "Bloggs"},
  {first: "Mary", last: "Albright"}
];
a = a.sort((a, b) => {
  var rv = a.last.localeCompare(b.last);
  if (rv === 0) {
    rv = a.first.localeCompare(b.first);
  }
  return rv;
});
console.log(JSON.stringify(a));

Die version ohne { ... } wird als Pfeil-Funktion mit einem Ausdruck Körper oder prägnant Körper. (Auch: Ein prägnant Pfeil-Funktion.) Das mit { ... } Definition der Körper ist ein Pfeil-Funktion mit einem Funktion Körper. (Auch: Ein ausführliche Pfeil-Funktion.)

Methode Erklärung im Objekt-Initialisierer (ES2015+)

ES2015 ermöglicht eine kürzere form erklärt, eine Eigenschaft, die auf eine Funktion namens ein Methode definition; es sieht wie folgt aus:

var o = {
    foo() {
    }
};

den fast-äquivalent bei 5 und früher wäre:

var o = {
    foo: function foo() {
    }
};

den Unterschied (außer Ausführlichkeit) ist, dass eine Methode verwenden super, aber eine Funktion nicht. So zum Beispiel, wenn Sie hatte ein Objekt definiert, dass (sagen wir) valueOf mit der Methode syntax, es könnte super.valueOf() um den Wert Object.prototype.valueOf wieder zurück haben möchte (vor vermutlich etwas anderes zu tun mit ihm), in der Erwägung, dass die ES5-version zu tun haben Object.prototype.valueOf.call(this) statt.

Das bedeutet auch, dass die Methode eine Referenz auf das Objekt, das es definiert wurde, also wenn das Objekt temporär (zum Beispiel, Sie ' re passing es in Object.assign als einer der source-Objekte), Methode syntax könnte bedeuten, dass das Objekt im Speicher bleiben, wenn es sonst gewesen sein könnte Müll gesammelt (wenn die JavaScript-engine nicht erkennt, dass die situation und behandeln Sie es, wenn keiner der Methoden verwendet super).

Konstruktor und Methode Erklärungen in class (ES2015+)

ES2015 bringt uns class syntax, einschließlich der deklarierten Konstruktoren und Methoden:

class Person {
    constructor(firstName, lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    getFullName() {
        return this.firstName + " " + this.lastName;
    }
}

Gibt es zwei Funktions-Deklarationen vor: Eine für den Konstruktor, der den Namen Person, und eine für getFullName, der eine Funktion zugewiesen Person.prototype.

InformationsquelleAutor T.J. Crowder

Den beiden code-snippets, die du da gepostet hast, die für fast alle Zwecke, die gleiche Weise Verhalten.

Jedoch der Unterschied im Verhalten ist, dass mit der ersten Variante (var functionOne = function() {}), die Funktion kann nur aufgerufen werden, nachdem dieser Punkt im code.

Mit der zweiten Variante (function functionTwo()), die Funktion steht code, der ausgeführt wird, über dem die Funktion deklariert ist.

Dies ist, weil mit der ersten Variante, dem die Funktion zugeordnet ist die variable foo zur Laufzeit. In der zweiten, der die Funktion zugeordnet ist, der Bezeichner, foo an-parse-Zeit.

Weitere technische Informationen

JavaScript hat drei Möglichkeiten der Definition von Funktionen.

1. Ihre erste Ausschnitt zeigt eine Funktion Ausdruck. Dies beinhaltet die Verwendung der " - Funktion" operator um eine Funktion zu erstellen - das Ergebnis, dass der Bediener können gespeichert werden, in eine variable oder eine Objekteigenschaft. Die Funktion Ausdruck ist mächtig, Weise. Die Funktion Ausdruck wird oft als eine "anonyme Funktion", weil es nicht um einen Namen,
2. Dein zweites Beispiel ist ein Funktion Erklärung. Dies nutzt die "function" - Anweisung um eine Funktion zu erstellen. Die Funktion zur Verfügung gestellt wird zur Analysezeit und können überall aufgerufen werden, in diesem Bereich. Sie können noch speichern es in einer Variablen-oder Objekt-Eigenschaft später.
3. Die Dritte Möglichkeit der Definition einer Funktion ist die "Funktion ()" - Konstruktor, die nicht angezeigt wird in Ihre original-Beitrag. Es ist nicht empfohlen, diese zu verwenden, wie es funktioniert auf die gleiche Weise wie eval() hat Ihre Probleme.

InformationsquelleAutor thomasrutter

Anderen Kommentatoren bereits zurückgelegt haben der semantische Unterschied der beiden Varianten oben. Ich wollte beachten einen stilistischen Unterschied: Nur die "Belegung" Variante festlegen einer Eigenschaft eines anderen Objekts.

Ich oft bauen JavaScript-Module mit einem Muster wie dieses:

(function(){
    var exports = {};

    function privateUtil() {
            ...
    }

    exports.publicUtil = function() {
            ...
    };

    return exports;
})();

Diesem Muster, Ihren öffentlichen Funktionen verwenden alle die Abtretung, während Ihre privaten Funktionen verwenden Erklärung.

(Beachten Sie auch, dass die Zuordnung sollte erfordern ein Semikolon nach der Anweisung, während die Deklaration verbietet es.)

InformationsquelleAutor Sean McMillan

Ein wichtiger Grund ist das hinzufügen von eine und nur eine variable als "Root" - namespace...

var MyNamespace = {}
MyNamespace.foo= function() {

}

oder

var MyNamespace = {
  foo: function() {
  },
  ...
}

Gibt es viele Techniken für Verwendung von Namensräumen. Es ist wichtiger geworden mit der fülle von JavaScript-Modulen zur Verfügung.

Siehe auch Wie kann ich deklarieren einen namespace in JavaScript?

InformationsquelleAutor Rob

Ich bin hinzufügen, meine Antwort, nur weil alle anderen abgedeckt hat, den Hub-Teil gründlich.

Hab ich mich gewundert über den Weg, ist besser für eine lange Zeit jetzt, und Dank http://jsperf.com jetzt weiß ich es 🙂

Funktionsdeklarationen sind schneller, und das ist, was wirklich zählt in web-dev, richtig? 😉

InformationsquelleAutor Leon Gaban

Das erste Beispiel ist eine Funktion Erklärung:

function abc(){}

Das zweite Beispiel ist eine Funktion Ausdruck:

var abc = function() {};

Der wesentliche Unterschied ist, wie Sie gehisst werden, (aufgehoben und erklärt). Im ersten Beispiel, die ganze Funktion Erklärung ist gehisst. Im zweiten Beispiel wird nur die var " abc " ist gehisst, wird der Wert (die Funktion) werden nicht definiert und die Funktion selbst bleibt an der position, in der Sie deklariert ist.

Um es einfach auszudrücken:

//this will work
abc(param);
function abc(){}

//this would fail
abc(param);
var abc = function() {}

Studium mehr zu diesem Thema, die ich empfehlen Ihnen dringend, diese
link

InformationsquelleAutor sla55er

Verwende ich die variable Ansatz in meinem code für einen ganz bestimmten Grund, die Theorie, die gewesen bedeckt in abstrakter Weise vor, aber ein Beispiel mag helfen, einige Leute wie mich, die mit begrenzten JavaScript-know-how.

Habe ich code, den ich ausführen muss, mit 160-unabhängig-brandings entwickelt. Die meisten der code in freigegebenen Dateien, aber branding-spezifische Zeug ist in einer separaten Datei, einer für jedes branding.

Einige Marken erfordern spezifische Funktionen, und einige tun nicht. Manchmal habe ich auch das hinzufügen neuer Funktionen für die neue branding-spezifische Dinge. Ich bin froh, ändern Sie die freigegebenen codiert, aber ich will nicht zu ändern, alle 160 Sätze von branding-Dateien.

Indem Sie die variable syntax, ich kann die variable deklariert (eine Funktion, die Zeiger im wesentlichen) in den gemeinsamen code und entweder weisen eine triviale stub-Funktion oder auf null gesetzt.

Den ein oder zwei Marken, die eine spezielle Implementierung der Funktion können dann definieren, Ihre version der Funktion und weisen Sie diese der Variablen, wenn Sie wollen, und der rest tut nichts. Ich kann den test für null-Funktion, bevor ich es ausführen in den gemeinsamen code.

Von Menschen die Kommentare oben, ich nehme an, es könnte möglich sein, neu zu definieren, eine statische Funktion zu, aber ich denke, dass die variable Lösung ist schön und klar.

InformationsquelleAutor Herc

Greg ' s Antwort ist gut genug, aber ich möchte noch etwas hinzufügen, die ich gelernt, nur jetzt gerade Douglas Crockford ist videos.

Funktion Ausdruck:

var foo = function foo() {};

Function-Anweisung:

function foo() {};

Den function-Anweisung ist einfach eine Kurzform für var - Anweisung mit einer function Wert.

So

function foo() {};

erweitert, um

var foo = function foo() {};

Welche expandiert weiter zu:

var foo = undefined;
foo = function foo() {};

Und Sie sind beide auf die Spitze gehievt der code.

InformationsquelleAutor Rohan

Ein weiterer Unterschied, der nicht erwähnt wird in den anderen Antworten, dass, wenn Sie die Verwendung der anonymen Funktion

var functionOne = function() {
    //Some code
};

und verwenden, die wie ein Konstruktor, wie in

var one = new functionOne();

dann one.constructor.name werden nicht definiert. Function.name ist nicht standard, sondern wird von Firefox, Chrome, other Webkit-abgeleiteten Browsern und IE 9+.

Mit

function functionTwo() {
    //Some code
}
two = new functionTwo();

ist es möglich, zum abrufen der name der Konstruktor als string mit two.constructor.name.

InformationsquelleAutor Ingo Kegel

Die erste (Funktion doSomething(x)) sollten Teil eines Objekts-notation.

Zweiten (var doSomething = function(x){ alert(x);}) ist, erstellen Sie einfach eine anonyme Funktion und Zuweisung an eine variable doSomething. So doSomething() wird die Funktion aufrufen.

Möchten Sie vielleicht wissen, was für ein Funktion Erklärung und Funktion Ausdruck ist.

Einer Funktionsdeklaration definiert eine benannte variable, Funktion ohne Variablen-Zuordnung. Funktionsdeklarationen auftreten als eigenständige Konstrukte und können nicht geschachtelt werden innerhalb der nicht-Funktions-blocks.

function foo() {
    return 3;
}

ECMA 5 (13.0) definiert die syntax

Funktion Identifier ( FormalParameterList_opt ) { FunctionBody }

In der obigen Bedingung der name der Funktion wird sichtbar in seinem Rahmen und Umfang, den Ihre Muttergesellschaft (sonst wäre es nicht erreichbar).

Und in einem Funktionsausdruck

Funktion-Ausdruck definiert eine Funktion als Teil eines größeren Ausdrucks-syntax (in der Regel eine variable Zuordnung ). Definierten Funktionen über Funktionen Ausdrücke können mit Namen oder anonym. Funktionsausdrücke sollte nicht beginnen mit "Funktion".

//Anonymous function expression
var a = function() {
    return 3;
}

//Named function expression
var a = function foo() {
    return 3;
}

//Self-invoking function expression
(function foo() {
    alert("hello!");
})();

ECMA 5 (13.0) definiert die syntax

Funktion Identifier_opt ( FormalParameterList_opt ) { FunctionBody }

InformationsquelleAutor NullPoiиteя

Im Licht der "benannten Funktionen zeigen, bis in stack-traces" - argument, modernen JavaScript-engines sind eigentlich durchaus in der Lage, die Vertretung anonyme Funktionen.

Schreiben, V8, SpiderMonkey, Chakra und Nitro beziehen sich immer auf die benannten Funktionen, die durch Ihre Namen. Sie fast immer beziehen sich auf eine anonyme Funktion, indem Sie Ihre id, wenn es eines hat.

SpiderMonkey herausfinden können, den Namen eines anonymen Funktion zurückgegeben, die von einer anderen Funktion. Der rest kann nicht.

Wenn Sie wirklich, wirklich wollten, dass Ihre iterator und Erfolg Rückrufe zu zeigen, bis in der Spur, Sie nennen könnten, auch diejenigen...

[].forEach(function iterator() {});

Aber zum größten Teil ist es nicht Wert, zu betonen, über.

Kabelbaum (Fiddle)

'use strict';

var a = function () {
    throw new Error();
},
    b = function b() {
        throw new Error();
    },
    c = function d() {
        throw new Error();
    },
    e = {
        f: a,
        g: b,
        h: c,
        i: function () {
            throw new Error();
        },
        j: function j() {
            throw new Error();
        },
        k: function l() {
            throw new Error();
        }
    },
    m = (function () {
        return function () {
            throw new Error();
        };
    }()),
    n = (function () {
        return function n() {
            throw new Error();
        };
    }()),
    o = (function () {
        return function p() {
            throw new Error();
        };
    }());

console.log([a, b, c].concat(Object.keys(e).reduce(function (values, key) {
    return values.concat(e[key]);
}, [])).concat([m, n, o]).reduce(function (logs, func) {

    try {
        func();
    } catch (error) {
        return logs.concat('func.name: ' + func.name + '\n' +
                           'Trace:\n' +
                           error.stack);
        //Need to manually log the error object in Nitro.
    }

}, []).join('\n\n'));

V8

func.name: 
Trace:
Error
    at a (http://localhost:8000/test.js:4:11)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: b
Trace:
Error
    at b (http://localhost:8000/test.js:7:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: d
Trace:
Error
    at d (http://localhost:8000/test.js:10:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: 
Trace:
Error
    at a (http://localhost:8000/test.js:4:11)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: b
Trace:
Error
    at b (http://localhost:8000/test.js:7:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: d
Trace:
Error
    at d (http://localhost:8000/test.js:10:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: 
Trace:
Error
    at e.i (http://localhost:8000/test.js:17:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: j
Trace:
Error
    at j (http://localhost:8000/test.js:20:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: l
Trace:
Error
    at l (http://localhost:8000/test.js:23:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: 
Trace:
Error
    at http://localhost:8000/test.js:28:19
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: n
Trace:
Error
    at n (http://localhost:8000/test.js:33:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: p
Trace:
Error
    at p (http://localhost:8000/test.js:38:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27 test.js:42

SpiderMonkey

func.name: 
Trace:
a@http://localhost:8000/test.js:4:5
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: b
Trace:
b@http://localhost:8000/test.js:7:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: d
Trace:
d@http://localhost:8000/test.js:10:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: 
Trace:
a@http://localhost:8000/test.js:4:5
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: b
Trace:
b@http://localhost:8000/test.js:7:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: d
Trace:
d@http://localhost:8000/test.js:10:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: 
Trace:
e.i@http://localhost:8000/test.js:17:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: j
Trace:
j@http://localhost:8000/test.js:20:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: l
Trace:
l@http://localhost:8000/test.js:23:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: 
Trace:
m</<@http://localhost:8000/test.js:28:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: n
Trace:
n@http://localhost:8000/test.js:33:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: p
Trace:
p@http://localhost:8000/test.js:38:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1

Chakra

func.name: undefined
Trace:
Error
   at a (http://localhost:8000/test.js:4:5)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at b (http://localhost:8000/test.js:7:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at d (http://localhost:8000/test.js:10:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at a (http://localhost:8000/test.js:4:5)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at b (http://localhost:8000/test.js:7:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at d (http://localhost:8000/test.js:10:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at e.i (http://localhost:8000/test.js:17:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at j (http://localhost:8000/test.js:20:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at l (http://localhost:8000/test.js:23:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at Anonymous function (http://localhost:8000/test.js:28:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at n (http://localhost:8000/test.js:33:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at p (http://localhost:8000/test.js:38:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)

Nitro

func.name: 
Trace:
a@http://localhost:8000/test.js:4:22
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: b
Trace:
b@http://localhost:8000/test.js:7:26
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: d
Trace:
d@http://localhost:8000/test.js:10:26
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: 
Trace:
a@http://localhost:8000/test.js:4:22
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: b
Trace:
b@http://localhost:8000/test.js:7:26
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: d
Trace:
d@http://localhost:8000/test.js:10:26
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: 
Trace:
i@http://localhost:8000/test.js:17:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: j
Trace:
j@http://localhost:8000/test.js:20:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: l
Trace:
l@http://localhost:8000/test.js:23:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: 
Trace:
http://localhost:8000/test.js:28:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: n
Trace:
n@http://localhost:8000/test.js:33:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: p
Trace:
p@http://localhost:8000/test.js:38:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

InformationsquelleAutor Jackson

Beide sind verschiedene Arten der Definition einer Funktion. Der Unterschied ist, wie der browser interpretiert und lädt diese in einen Kontext für die Ausführung.

Ersten Fall ist die Funktion Ausdrücke, die lädt nur, wenn der interpreter erreicht, dass die code-Zeile. Also, wenn du es so machst wie die folgenden, erhalten Sie eine Fehlermeldung, dass die functionOne ist nicht eine Funktion.

functionOne();
var functionOne = function() {
    //Some code
};

Der Grund ist, dass in der ersten Zeile kein Wert zugewiesen wird functionOne, und es ist daher nicht definiert. Versuchen wir es nennen, als eine Funktion, und damit bekommen wir einen Fehler.

In der zweiten Zeile wir der Zuordnung der Referenz von einer anonymen Funktion functionOne.

Zweiten Fall ist der Funktionsdeklarationen, die geladen wird, bevor irgendein code ausgeführt wird. Also, wenn Sie tun, wie die folgenden Sie erhalten keine Fehler, wie die Erklärung lädt vor dem ausführen von code.

functionOne();
function functionOne() {
   //Some code
}

InformationsquelleAutor Nitin9791

Sind Sie ziemlich ähnlich, mit einigen kleinen unterschieden, das erste ist eine variable, die zugeordnet, um eine anonyme Funktion (Funktions-Deklaration) und das zweite ist der normale Weg, um eine Funktion zu erstellen, die in JavaScript Anonyme Funktion-Deklaration), die beide die Nutzung, Nachteile und Vorteile:

1. Funktion Ausdruck

var functionOne = function() {
    //Some code
};

Funktion-Ausdruck definiert eine Funktion als Teil eines größeren
expression syntax (in der Regel eine variable Zuordnung ). Funktionen
definiert über Funktionen Ausdrücke können mit Namen oder anonym. Funktion
Ausdrücke dürfen nicht mit "Funktion" (daher die Klammern
um die sich selbst aufrufen Beispiel unten).

Einer Variablen zuweisen einer Funktion bedeutet nicht Hochziehen, wie wir wissen Funktionen in JavaScript kann Hissen, bedeutet, Sie können aufgerufen werden, bevor Sie deklariert, während die Variablen müssen deklariert werden, bevor man Zugang zu Ihnen haben, so bedeutet in diesem Fall können wir nicht auf die Funktion vor, wo es erklärt, es auch ein Weg sein könnte, dass Sie Ihre Funktionen schreiben, für die Funktionen, die Rückkehr einer anderen Funktion dieser Art von Erklärung könnte Sinn machen, auch in ECMA6 & oben können Sie diese zuordnen zu einem Pfeil-Funktion, die verwendet werden können, zu nennen, anonyme Funktionen, auch auf diese Weise zu deklarieren, ist ein besserer Weg, um erstellen Konstruktor-Funktionen in JavaScript.

2. Funktion Erklärung

function functionTwo() {
    //Some code
}

Einer Funktionsdeklaration definiert eine benannte variable, Funktion ohne
erfordern variable Zuordnung. Funktionsdeklarationen vorkommen, als
eigenständige Konstrukte und können nicht geschachtelt werden innerhalb der nicht-Funktions-blocks.
Es ist hilfreich, Sie als Geschwister von Variablen-Deklarationen.
Nur als Variablen-Deklaration beginnt mit "var", Funktion
Erklärungen muss beginnen mit "Funktion".

Dies ist der normale Weg, den Aufruf einer Funktion in JavaScript, kann diese Funktion aufgerufen werden, bevor Sie selbst es erklären, da in JavaScript alle Funktionen erhalten Gehisst, aber wenn du 'use strict' - das wird nicht Hissen, wie erwartet, es ist eine gute Möglichkeit zu nennen, alle normalen Funktionen, die nicht in großen Linien und weder eine Konstruktor-Funktion.

Auch, wenn Sie mehr Informationen darüber, wie Sie hochziehen funktioniert in JavaScript, besuchen Sie den link unten:

https://developer.mozilla.org/en-US/docs/Glossary/Hoisting

InformationsquelleAutor Alireza

new Function() können verwendet werden, um pass die Funktion, den Körper in einen string. Und damit dies kann verwendet werden, um dynamische Funktionen. Auch übergeben Sie das Skript ohne das Skript ausgeführt wird.

var func = new Function("x", "y", "return x*y;");
function secondFunction(){
   var result;
   result = func(10,20);
   console.log ( result );
}

secondFunction()

InformationsquelleAutor SuperNova