.
- Verfügbarkeit (Umfang) der Funktion
Das Folgende funktioniert, weil function add() ist auf den nächstgelegenen Block skaliert:
try {
console.log("Success: ", add(1, 1));
} catch(e) {
console.log("ERROR: " + e);
}
function add(a, b){
return a + b;
}
Das folgende Beispiel funktioniert nicht, da die Variable aufgerufen wird, bevor der Variablen ein Funktionswert zugewiesen wird add .
try {
console.log("Success: ", add(1, 1));
} catch(e) {
console.log("ERROR: " + e);
}
var add=function(a, b){
return a + b;
}
Der obige Code ist in seiner Funktionalität identisch mit dem nachstehenden Code. Beachten Sie, dass die explizite Zuweisung von add = undefined ist überflüssig, denn es genügt, die var add; ist genau dasselbe wie var add=undefined .
var add = undefined;
try {
console.log("Success: ", add(1, 1));
} catch(e) {
console.log("ERROR: " + e);
}
add = function(a, b){
return a + b;
}
Das Folgende funktioniert nicht, weil var add= beginnt einen Ausdruck und bewirkt Folgendes function add() ein Ausdruck anstelle eines Blocks zu sein. Benannte Funktionen sind nur für sich selbst und den sie umgebenden Block sichtbar. Als function add() hier ein Ausdruck ist, hat er keinen umgebenden Block, ist also nur für sich selbst sichtbar.
try {
console.log("Success: ", add(1, 1));
} catch(e) {
console.log("ERROR: " + e);
}
var add=function add(a, b){
return a + b;
}
- (Funktion) .name
Der Name einer Funktion function thefuncname(){} es thefuncname wenn es auf diese Weise deklariert wird.
function foobar(a, b){}
console.log(foobar.name);
var a = function foobar(){};
console.log(a.name);
Andernfalls, wenn eine Funktion deklariert ist als function(){} El Funktion .name ist die erste Variable, die zum Speichern der Funktion verwendet wird.
var a = function(){};
var b = (function(){ return function(){} });
console.log(a.name);
console.log(b.name);
Wenn der Funktion keine Variablen zugewiesen sind, ist der Funktionsname eine leere Zeichenkette ( "" ).
console.log((function(){}).name === "");
Schließlich legt die Variable, der die Funktion zugewiesen ist, zunächst den Namen fest, während nachfolgende Variablen, die der Funktion zugewiesen werden, den Namen nicht ändern.
var a = function(){};
var b = a;
var c = b;
console.log(a.name);
console.log(b.name);
console.log(c.name);
- Leistung
In Googles V8 und Firefox' Spidermonkey mag es einen Unterschied von ein paar Mikrosekunden bei der JIT-Kompilierung geben, aber letztlich ist das Ergebnis genau dasselbe. Um dies zu beweisen, wollen wir die Effizienz von JSPerf bei Mikro-Benchmarks untersuchen, indem wir die Geschwindigkeit von zwei leeren Codeschnipseln vergleichen. Die JSPerf-Tests finden Sie hier . Und, die jsben.ch Tests finden Sie hier . Wie Sie sehen können, gibt es einen spürbaren Unterschied, wenn es keinen geben sollte. Wenn Sie wie ich ein echter Leistungsfanatiker sind, sollten Sie versuchen, die Anzahl der Variablen und Funktionen im Anwendungsbereich zu reduzieren und vor allem Polymorphismus zu vermeiden (z. B. die Verwendung derselben Variablen zur Speicherung zweier unterschiedlicher Typen).
- Variable Veränderlichkeit
Wenn Sie die var um eine Variable zu deklarieren, können Sie der Variablen einen anderen Wert zuweisen, etwa so.
(function(){
"use strict";
var foobar = function(){}; // initial value
try {
foobar = "Hello World!"; // new value
console.log("[no error]");
} catch(error) {
console.log("ERROR: " + error.message);
}
console.log(foobar, window.foobar);
})();
Wenn wir jedoch die const-Anweisung verwenden, wird der Variablenverweis unveränderlich. Das bedeutet, dass wir der Variablen keinen neuen Wert zuweisen können. Bitte beachten Sie jedoch, dass der Inhalt der Variablen dadurch nicht unveränderlich wird: Wenn Sie const arr = [] dann können Sie immer noch arr[10] = "example" . Nur etwas tun wie arr = "new value" o arr = [] würde einen Fehler auslösen (siehe unten).
(function(){
"use strict";
const foobar = function(){}; // initial value
try {
foobar = "Hello World!"; // new value
console.log("[no error]");
} catch(error) {
console.log("ERROR: " + error.message);
}
console.log(foobar, window.foobar);
})();
Interessanterweise, wenn wir die Variable deklarieren als function funcName(){} ist die Unveränderlichkeit der Variablen die gleiche wie bei der Deklaration mit var .
(function(){
"use strict";
function foobar(){}; // initial value
try {
foobar = "Hello World!"; // new value
console.log("[no error]");
} catch(error) {
console.log("ERROR: " + error.message);
}
console.log(foobar, window.foobar);
})();
" "
Der "nächstgelegene Block" ist die nächstgelegene "Funktion" (einschließlich asynchroner Funktionen, Generatorfunktionen und asynchroner Generatorfunktionen). Interessant ist jedoch, dass ein function functionName() {} verhält sich wie ein var functionName = function() {} in einem nicht verschlossenen Block auf Gegenstände außerhalb dieses Verschlusses. Beachten Sie.
-
Normal var add=function(){}
try {
// typeof will simply return "undefined" if the variable does not exist
if (typeof add !== "undefined") {
add(1, 1); // just to prove it
console.log("Not a block");
}else if(add===undefined){ // this throws an exception if add doesn't exist
console.log('Behaves like var add=function(a,b){return a+b}');
}
} catch(e) {
console.log("Is a block");
}
var add=function(a, b){return a + b}
-
Normal function add(){}
try {
// typeof will simply return "undefined" if the variable does not exist
if (typeof add !== "undefined") {
add(1, 1); // just to prove it
console.log("Not a block");
}else if(add===undefined){ // this throws an exception if add doesn't exist
console.log('Behaves like var add=function(a,b){return a+b}')
}
} catch(e) {
console.log("Is a block");
}
function add(a, b){
return a + b;
}
-
Funktion
try {
// typeof will simply return "undefined" if the variable does not exist
if (typeof add !== "undefined") {
add(1, 1); // just to prove it
console.log("Not a block");
}else if(add===undefined){ // this throws an exception if add doesn't exist
console.log('Behaves like var add=function(a,b){return a+b}')
}
} catch(e) {
console.log("Is a block");
}
(function () {
function add(a, b){
return a + b;
}
})();
-
Anweisung (wie z.B. if , else , for , while , try / catch / finally , switch , do / while , with )
try {
// typeof will simply return "undefined" if the variable does not exist
if (typeof add !== "undefined") {
add(1, 1); // just to prove it
console.log("Not a block");
}else if(add===undefined){ // this throws an exception if add doesn't exist
console.log('Behaves like var add=function(a,b){return a+b}')
}
} catch(e) {
console.log("Is a block");
}
{
function add(a, b){
return a + b;
}
}
-
Pfeilfunktion mit var add=function()
try {
// typeof will simply return "undefined" if the variable does not exist
if (typeof add !== "undefined") {
add(1, 1); // just to prove it
console.log("Not a block");
}else if(add===undefined){ // this throws an exception if add doesn't exist
console.log('Behaves like var add=function(a,b){return a+b}')
}
} catch(e) {
console.log("Is a block");
}
(() => {
var add=function(a, b){
return a + b;
}
})();
-
Pfeilfunktion mit function add()
try {
// typeof will simply return "undefined" if the variable does not exist
if (typeof add !== "undefined") {
add(1, 1); // just to prove it
console.log("Not a block");
}else if(add===undefined){ // this throws an exception if add doesn't exist
console.log('Behaves like var add=function(a,b){return a+b}')
}
} catch(e) {
console.log("Is a block");
}
(() => {
function add(a, b){
return a + b;
}
})();
