Detaillierte Erläuterung der JavaScript-Funktionen

In vielen traditionellen Sprachen (C/C++/Java/C# usw.) existieren Funktionen als Bürger zweiter Klasse. Sie können eine Funktion nur mit Sprachschlüsselwörtern deklarieren und sie dann bei Bedarf aufrufen Wenn eine Funktion als Parameter an eine andere Funktion übergeben, einer lokalen Variablen zugewiesen oder als Rückgabewert verwendet wird, sind spezielle Methoden wie Funktionszeiger und Delegaten erforderlich.

In der JavaScript-Welt sind Funktionen erstklassige Bürger. Sie verfügen nicht nur über alle Möglichkeiten, herkömmliche Funktionen zu verwenden (Deklaration und Aufruf), sondern können auch auf einfache Weise zugewiesen und übergeben werden Parameter und Rückgabewerte, eine solche Funktion wird auch als erstklassige Funktion bezeichnet. Darüber hinaus fungiert die Funktion in JavaScript auch als Konstruktor der Klasse und ist eine Instanz der Function-Klasse. Aufgrund dieser Mehrfachidentitäten sind JavaScript-Funktionen sehr wichtig.

1. JavaScript-Funktionen der Einstiegsklasse

Wie andere Sprachen folgen auch JavaScript-Funktionen zunächst dem Prinzip der Deklaration und können dann nur Buchstaben, Zahlen usw. enthalten. Unterstriche oder $ dürfen nicht mit einer Zahl beginnen. Es gibt zwei gängige Methoden zum Deklarieren von Funktionen:

Der Code lautet wie folgt:

 // 直接声明函数myfunc 
 function myfunc(/* arguments */) { 
 } 
   
 // 把匿名函数赋值给本地变量myfunc 
 var myfunc = function(/* arguments */) { 
 }

Beachten Sie, dass es subtile Unterschiede zwischen den beiden oben genannten Methoden zum Deklarieren von Funktionen gibt: Die erste Methode ist a Auf benannte Funktionen kann im gesamten Gültigkeitsbereich zugegriffen werden, unabhängig davon, ob sie vor dem Aufruf, nach dem Aufruf oder sogar an einer Position deklariert wurden, die nicht ausgeführt wird (z. B. nach der Return-Anweisung oder in einem Zweig, der niemals wahr sein wird). Typ Die Methode besteht darin, einer Variablen eine anonyme Funktion zuzuweisen. Streng genommen handelt es sich hierbei nicht um eine Funktionsdeklaration, sondern um einen Funktionsausdruck. Auf diese Funktion kann vor der Zuweisung nicht zugegriffen werden aufrufen, sonst kommt es beim Aufruf zu einem Fehler: „TypeError: undefiniert ist keine Funktion“. Zum Beispiel:

Der Code lautet wie folgt:

 myfunc1(); // 能够正常调用，因为myfunc1采用直接声明的方式 
   
 function myfunc1() { 
 } 
   
 myfunc2(); // 出错 TypeError: undefined is not a function 
   
 var myfunc2 = function() { 
 };

Die grundlegende Aufrufmethode der Funktion ist die gleiche wie in herkömmlichen Sprachen. Sie wird mit einem Klammerpaar aufgerufen: myfunc (). JavaScript-Funktionen unterstützen auch direkte oder indirekte rekursive Aufrufe. Beispielsweise kann die klassische Fibonacci-Funktion wie folgt in JavaScript implementiert werden:

Der Code lautet wie folgt:

 function fib(n) { 
   if (n == 1 || n == 2) { 
     return 1; 
   } else { 
     return fib(n - 2) + fib(n - 1); 
   } 
 }

Funktionen in JavaScript können Parameter variabler Länge verarbeiten. Innerhalb der Funktion gibt es eine lokale Variable namens arguments, die ein Array-ähnliches Objekt ist, das alle während des Aufrufs übergebenen Parameter enthält . Zum Beispiel:

Der Code lautet wie folgt:

 function test() { 
   alert(arguments.length); 
 } 
   
 test(1); // 1 
 test(1, 'a'); // 2 
 test(true, [], {}); // 3 利用arguments可以实现类似C语言printf的功能，也可以用来实现方法的多态。

2. Erweiterte JavaScript-Funktionen

2.1 Anonyme Funktionen und verschachtelte Funktionen

In JavaScript können Sie eine Funktion ohne Namen deklarieren, die als anonyme Funktion (Anonymouse-Funktion) bezeichnet wird. Gleichzeitig ermöglicht JavaScript auch die Deklaration von Funktionen innerhalb von Funktionen, sogenannte verschachtelte Funktionen. Der Geltungsbereich einer verschachtelten Funktion ist die gesamte übergeordnete Funktion.

Im vorherigen Abschnitt zur Funktionsdeklaration haben wir die Verwendung anonymer Funktionen und verschachtelter Funktionen gesehen. Da anonyme Funktionen keine Namen haben, führen sie keine neuen Variablen ein, die den Kontext verschmutzen, und bringen neue Variableneffekte mit sich Daher werden häufig anonyme Funktionen verwendet, um eine globale Umweltverschmutzung zu verhindern.

In der JavaScript-Laufzeit gibt es eine spezielle globale Umgebung (globales Objekt). In der tatsächlichen Entwicklung werden häufig mehrere Bibliotheken von Drittanbietern oder mehrere JS-Dateien verwendet Führen Sie wiederholte Variablen- oder Funktionsdeklarationen in das globale Objekt ein, was zu Verwirrung bei der Codeausführung führt. Beispielsweise werden zwei js-Dateien nacheinander eingeführt und jede definiert ihr eigenes Funktionsprotokoll für den internen Gebrauch. Die zweite eingeführte Funktion überschreibt die erste Definition und löst keine Fehler aus. Der Aufruf der Protokollfunktion bei nachfolgenden Ausführungen kann zu Problemen führen. Fehler verursachen. Derzeit kann dieser Fehler vermieden werden, indem eine anonyme Funktion zum Einschließen der Logik in das gesamte JS verwendet wird. Diese Methode wurde von den meisten Open-Source-JS-Bibliotheken verwendet.

Der Code lautet wie folgt:

 (function() { // 匿名函数 
   
 function log(msg) { 
     console.log(msg); 
 } 
   
 // 其他代码 
   
 }()); // 立即执行

Der obige Code ist ein einfaches Beispiel. Der Umfang der Protokollfunktion ist auf diese anonyme Funktion beschränkt , und Die anonyme Funktion ist von einem Klammerpaar () umgeben und bildet einen Funktionsausdruck. Der Wert des Ausdrucks ist eine Funktion. Das folgende Klammerpaar gibt an, dass die Funktion sofort ausgeführt wird, sodass der ursprüngliche Code ausgeführt werden kann normalerweise. Auf diese Weise deklarierte Funktionen, über var deklarierte Variablen usw. sind jedoch intern und können von keinem anderen Code als anonymen Funktionen aufgerufen werden. Wenn Sie einige Funktionen als Schnittstellen verfügbar machen müssen, gibt es mehrere Methoden:

Der Code lautet wie folgt:

 var mylib = (function(global) { 
   
 function log(msg) { 
   console.log(msg); 
 } 
   
 log1 = log;  // 法一：利用没有var的变量声明的默认行为，在log1成为全局变量（不推荐） 
   
 global.log2 = log;  // 法二：直接在全局对象上添加log2属性，赋值为log函数（推荐） 
   
 return {  // 法三：通过匿名函数返回值得到一系列接口函数集合对象，赋值给全局变量mylib（推荐） 
    log: log
 }; 
   
 }(window));

2.2 Höher -Funktionen (Funktion höherer Ordnung)

Wenn eine Funktion als Parameter oder Rückgabewert verwendet wird, wird sie als Funktion höherer Ordnung bezeichnet. Alle Funktionen in JavaScript können als verwendet werden Funktionen höherer Ordnung sind auch Merkmale von Funktionen erster Art. Im Folgenden werden wir diese beiden Verwendungsmethoden analysieren.

 代码如下:

 function negative(n) { 
   return -n; // 取n的相反值 
 } 
   
 function square(n) { 
   return n*n; // n的平方 
 } 
   
 function process(nums, callback) { 
   var result = []; 
   
   for(var i = 0, length = nums.length; i < length; i++) { 
     result[i] = callback(nums[i]); // 对数组nums中的所有元素传递给callback进行处理，将返回值作为结果保存 
   } 
   
   return result; 
 } 
   
 var nums = [-3, -2, -1, 0, 1, 2, 3, 4]; 
 var n_neg = process(nums, negative); 
 // n_neg = [3, 2, 1, 0, -1, -2, -3, -4]; 
 var n_square = process(nums, square); 
 // n_square = [9, 4, 1, 0, 1, 4, 9, 16];

以上代码展示了把函数作为参数传入另一个函数process调用的示例，在process函数的实现中，把callback作为一个黑盒子看待，负责把参数传给它，然后获取返回值，在调用之前并不清楚callback的具体实现。只有当执行到20行和22行时，callback才被分别代表negative或square，分别对每个元素进行取相反值或平方值的操作。

 代码如下:

 function generator() { 
   var i = 0; 
   return function() { 
     return i++; 
   }; 
 } 
   
 var gen1 = generator(); // 得到一个自然数生成器 
 var gen2 = generator(); // 得到另一个自然数生成器 
 var r1 = gen1(); // r1 = 0 
 var r2 = gen1(); // r2 = 1 
 var r3 = gen2(); // r3 = 0 
 var r4 = gen2(); // r4 = 1

上面的代码展示了把函数作为返回值的示例，generator是一个自然数生成器函数，返回值是一个自然数生成函数。每次调用generator时都会把一个匿名函数作为结果返回，这个匿名函数在被实际调用时依次返回每个自然数。在generator里的变量i在每次调用这个匿名函数时都会自增1，这其实就是一个闭包。下面我们来介绍一下闭包.
 
2.3 闭包（Closure）
闭包(Closure)并不是一个新鲜的概念，很多函数式语言中都使用了闭包。在JavaScript中，当你在内嵌函数中使用外部函数作用域内的变量时，就是使用了闭包。用一个常用的类比来解释闭包和类（Class）的关系：类是带函数的数据，闭包是带数据的函数。
闭包中使用的变量有一个特性，就是它们不在父函数返回时释放，而是随着闭包生命周期的结束而结束。比如像上一节中generator的例子，gen1和gen2分别使用了相互独立的变量i（在gen1的i自增1的时候，gen2的i并不受影响，反之亦然），只要gen1或gen2这两个变量没有被JavaScript引擎垃圾回收，他们各自的变量i就不会被释放。在JavaScript编程中，不知不觉就会使用到闭包，闭包的这个特性在带来易用的同时，也容易带来类似内存泄露的问题。例如：

 代码如下:

 var elem = document.getElementById('test'); 
 elem.addEventListener('click', function() { 
   alert('You clicked ' + elem.tagName); 
 });

这段代码的作用是点击一个结点时显示它的标签名称，它把一个匿名函数注册为一个DOM结点的click事件处理函数，函数内引用了一个DOM对象elem，就形成了闭包。这就会产生一个循环引用，即：DOM->闭包->DOM->闭包...DOM对象在闭包释放之前不会被释放；而闭包作为DOM对象的事件处理函数存在，所以在DOM对象释放前闭包不会释放，即使DOM对象在DOM tree中删除，由于这个循环引用的存在，DOM对象和闭包都不会被释放。可以用下面的方法可以避免这种内存泄露：

代码如下:

 var elem = document.getElementById('test'); 
 elem.addEventListener('click', function() { 
   alert('You clicked ' + this.tagName); // 不再直接引用elem变量 
 });

上面这段代码中用this代替elem（在DOM事件处理函数中this指针指向DOM元素本身），让JS运行时不再认为这个函数中使用了父类的变量，因此不再形成闭包。
闭包还会带来很多类似的内存泄露问题，只有在写代码的时候着重注意一下闭包，尽量避免此类的问题产生。
 
2.4 类构造函数
JavaScript的函数同时作为类的构造函数，因此只要声明一个函数就可以使用new关键字创建类的实例。

 代码如下:

function Person(name) { 
   this.name = name; 
   this.toString = function() { 
     return 'Hello, ' + this.name + '!'; 
   }; 
 } 
   
 var p = new Person('Ghostheaven');

 alert(p); // Hello, Ghostheaven! 在以上实例中Person函数作为类的构造函数使用，此时this指向新创建的实例对象，可以为实例增加属性和方法，关于详细的面向对象的JavaScript编程可以参考这篇文章。这里我想要说的是，JavaScript函数作为类构造函数使用时的返回值问题。

代码如下:

 function MyClass(name) { 
   this.name = name; 
   return name;  // 构造函数的返回值? 
 } 
   
 var obj1 = new MyClass('foo'); 
 var obj2 = MyClass('foo'); 
 var obj3 = new MyClass({}); 
 var obj4 = MyClass({});

上面的构造函数比较特别，有返回语句，那么obj1~obj4分别指向什么对象呢？实际结果是这样的：

复制代码 代码如下:

obj1 = MyClass对象
obj2 = 'foo'
obj3 = {}
obj4 = {}

具体原因这篇文章有解释，本文不再赘述，由于带返回值的构造函数会产生奇怪的结果，因此不要在构造函数中调用有返回值的返回语句（空return可以）。

三、JavaScript函数妖怪级

欢迎来到妖怪级函数授课区，在这里会交给你如何淡定自如地面对老怪。。。
 
3.1 Function类
在JavaScript运行时中有一个内建的类叫做Function，用function关键字声明一个函数其实是创建Function类对象的一种简写形式，所有的函数都拥有Function类所有的方法，例如call、apply、bind等等，可以通过instanceof关键字来验证这个说法。
既然Function是一个类，那么它的构造函数就是Function（它本身也是Function类的对象），应该可以通过new关键字来生成一个函数对象。第一个妖怪来了，那就是如何用Function类构造一个函数。Function的语法如下：

代码如下:

new Function ([arg1[, arg2[, ... argN]],] functionBody)

其中arg1, arg2, ... argN是字符串，代表参数名称，functionBody也是字符串，表示函数体，前面的参数名称是可多可少的，Function的构造函数会把最后一个参数当做函数体，前面的都当做参数处理。

 代码如下:

 var func1 = new Function('name', 'return "Hello, " + name + "!";'); 
 func1('Ghostheaven'); // Hello, Ghostheaven!

以上方法就通过Function构造了一个函数，这个函数跟其他用function关键字声明的函数一模一样。
看到这儿，很多人可能会问为什么需要这样一个妖怪呢？“存在的即是合理的”，Function类有它独特的用途，你可以利用它动态地生成各种函数逻辑，或者代替eval函数的功能，而且能保持当前环境不会被污染*。
 
 
3.2 自更新函数（Self-update Function）
在很多语言中，函数一旦声明过就不能再次声明同名函数，否则会产生语法错误，而在JavaScript中的函数不仅可以重复声明，而且还可以自己更新自己。自己吃自己的妖怪来了！

 代码如下:

 function selfUpdate() { 
   window.selfUpdate = function() { 
     alert('second run!'); 
   }; 
   
   alert('first run!'); 
 } 
   
 selfUpdate(); // first run! 
 selfUpdate(); // second run! 这种函数可以用于只运行一次的逻辑，在第一次运行之后就整个替换成一段新的逻辑。

小结

JavaScript的函数灰常强大，在漂亮地解决很多问题的同时，也带来很多负面问题。妖怪级别的函数使用方法通常是一些鲜为人知的用法，除非特别必要不要轻易使用，否则会造成代码阅读困难，影响团队开发效率。
 
* 在新的ECMAScript中引入了严格模式，在严格模式下eval函数受到了很大的限制，也能够保证环境不被污染

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der JavaScript-Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!