Detaillierte Erläuterung von 4 JavaScript-Konzepten von Node.js

Ausführliche Erklärung von 4 JavaScript-Konzepten in Node.js

Wäre es nicht erstaunlich, wenn Sie nur eine Programmiersprache beherrschen müssten, um eine Full-Stack-Anwendung zu erstellen? Um diese Idee Wirklichkeit werden zu lassen, hat Ryan Dahl node.js erstellt. Node.js ist ein serverseitiges Framework, das auf der leistungsstarken V8-JavaScript-Engine von Chrome basiert. Obwohl die Anwendung ursprünglich in C++ geschrieben wurde, läuft sie über JavaScript.

Auf diese Weise ist das Problem gelöst. Eine Sprache kann sie alle beherrschen. Darüber hinaus müssen Sie in der gesamten Anwendung nur diese eine Sprache verwenden. Daher müssen wir ein tiefes Verständnis von node.js haben. Darum geht es in diesem Artikel.

Die folgenden vier Grundkonzepte sind notwendig, damit Sie node.js beherrschen. Ich werde sie Ihnen in einer möglichst kurzen Geschichte vorstellen.

1. Nicht blockierende oder asynchrone E/A

Da Node.js ein serverseitiges Framework ist, besteht eine seiner Hauptaufgaben darin, es zu verwalten Browsing-Server-Anfrage. In einem herkömmlichen I/O-System wird die aktuelle Anfrage erst ausgegeben, wenn die Antwort (HTML-Seite) der vorherigen Anfrage eingetroffen ist. Aus diesem Grund wird es als blockierende E/A bezeichnet. Der Server blockiert andere Anfragen, um die aktuelle Anfrage zu verarbeiten, was dazu führt, dass der Browser wartet.

Node.js folgt diesem I/O-Prinzip nicht. Wenn eine Anfrage lange dauert, sendet Node.js die Anfrage an die Ereignisschleife und fährt mit der Verarbeitung der nächsten Anfrage im Aufrufstapel fort. Sobald die Verarbeitung der ausstehenden Anfrage abgeschlossen ist, teilt es Node.js mit und die Antwort wird im Browser gerendert.

Verwenden Sie ein Dummy-Beispiel, um dies zu verstehen:

Blockieren von E/A

// take order for table 1 and wait...
var order1 = orderBlocking(['Coke', 'Iced Tea']);
// once order is ready, take order back to table.
serveOrder(order1);
// once order is delivered, move on to another table.
// take order for table 2 and wait...
var order2 = orderBlocking(['Coke', 'Water']);
// once order is ready, take order back to table.
serveOrder(order2);
// once order is delivered, move on to another table.
// take order for table 3 and wait...
var order3 = orderBlocking(['Iced Tea', 'Water']);
// once order is ready, take order back to table.
serveOrder(order3);
// once order is delivered, move on to another table.

In diesem Restaurantbeispiel gibt der Kellner die Speisekarte und wartet auf die Bestellung fertig, dann gehen Sie zurück zum Tisch und servieren Sie das Menü. Während der aktuelle Kunde bestellt, wartet der Kellner in der Nähe und nimmt keine Menüs von anderen Kunden entgegen.

Nicht blockierende E/A

// take order for table 1 and move on...
orderNonBlocking(['Coke', 'Iced Tea'], function(drinks){
  return serveOrder(drinks);
});
// take order for table 2 and move on...
orderNonBlocking(['Beer', 'Whiskey'], function(drinks){
  return serveOrder(drinks);
});
// take order for table 3 and move on...
orderNonBlocking(['Hamburger', 'Pizza'], function(food){
  return serveOrder(food);
});

In diesem Beispiel erhält der Kellner die Speisekarte, sagt es dem Koch und geht dann zurück, um eine weitere Speisekarte zu holen. Während er das erste Menü fertigstellt, bedient er nicht nur die aktuellen Kunden in der richtigen Reihenfolge, sondern nimmt auch Bestellungen anderer Kunden entgegen. Kellner verschwenden keine Zeit, indem sie Bestellungen anderer Kunden blockieren.

2. Prototyp

Prototyp ist ein komplexes Konzept in JavaScript. Da Sie in Node.js jedoch häufig Prototypen verwenden, muss jeder JavaScript-Entwickler dieses Konzept verstehen.

In Sprachen, die klassische Vererbung implementieren, wie Java oder C++, müssen Sie für Sprachen mit Blick auf die Wiederverwendung von Code zunächst eine Klasse schreiben und dann Objekte aus dieser Klasse erstellen oder diese erweitern Klasse. Allerdings existiert das Konzept von Klassen in JavaScript nicht. Erstellen Sie zunächst ein Objekt in JavaScript und fügen Sie dann Ihre eigenen Objekte aus diesem Objekt hinzu oder erstellen Sie neue Objekte. Dies wird als archetypische Vererbung und Verwirklichung durch Archetypen bezeichnet.

Jedes JavaScript-Objekt ist mit einem Prototypobjekt verknüpft, von dem es Eigenschaften erben kann. Prototypen ähneln Klassen in anderen OO-Sprachen, der Unterschied besteht jedoch darin, dass sie selbst auch Objekte sind. Jedes Objekt ist mit Object.prototype verknüpft und Object.prototype wird mit vordefiniertem JavaScript geliefert.

Wenn Sie eine Eigenschaft über obj.propName oder obj['propName'] suchen und das Objekt keine Eigenschaft hat, die über obj.hasOwnProperty('propName') überprüft werden kann, wird dies bei der JavaScript-Laufzeit der Fall sein Suchen Sie nach Eigenschaften in Prototypobjekten. Wenn das Prototypobjekt über eine solche Eigenschaft nicht verfügt, werden seine Prototypen der Reihe nach überprüft, bis eine Übereinstimmung gefunden wird oder Object.prototype erreicht wird. Wenn für die Eigenschaft keine Prototypenkette vorhanden ist, führt dies zu einem undefinierten Wert.

Verstehen Sie dieses Konzept mit dem folgenden Beispielcode:

if (typeof Object.create !== 'function') {
    Object.create = function (o) {
        var F = function () {};
        F.prototype = o;
        return new F();
    };
var otherPerson = Object.create(person);

Wenn Sie ein neues Objekt erstellen, müssen Sie ein Objekt auswählen, das sein Prototyp sein soll. Hier fügen wir der Objektfunktion eine Methode hinzu. Diese Methode erstellt ein neues Objekt unter Verwendung eines anderen Objekts als Prototyp, der ihm als Parameter übergeben wird.

Wenn wir ein neues Objekt ändern, ist sein Prototyp davon nicht betroffen. Wenn wir jedoch Änderungen an einem Prototypobjekt vornehmen, sind diese Änderungen für alle auf diesem Prototyp basierenden Objekte sichtbar.

Prototyp ist ein komplexes Konzept. Darauf werde ich in einem anderen Artikel näher eingehen.

3. Module

Wenn Sie jemals mit Paketen in Java in Berührung gekommen sind, sind Module in Node.js nicht anders. Wenn nicht, dann machen Sie sich keine Sorgen. Module sind einfache JavaScript-Dateien, die Code für einen bestimmten Zweck enthalten. Das Modulmuster wird verwendet, um die Navigation und Verwendung Ihres Codes zu vereinfachen. Um ein Modulattribut verwenden zu können, müssen Sie es in einer JavaScript-Datei angeben, ähnlich wie beim Importieren eines Pakets in eine Java-Klasse.

Es gibt zwei Arten von Modulen in node.js.

Kernmodule – Diese Module sind mit der Node.js-Bibliothek vorkompiliert. Der Zweck von Kernmodulen besteht darin, Entwicklern häufig auftretende und sich wiederholende Codefragmente zur Verfügung zu stellen, die, wenn sie nicht verfügbar wären, Entwickler in die Lage versetzen würden, immer wieder denselben Code schreiben zu müssen. Einige gängige Kernmodule sind HTTP, URL, EVENTS, FILE SYSTEM usw.

用户定义模块——用户定义模块是开发人员在应用程序内创建用于特定目的的模块。当核心模块不能满足期望功能的时候就需要用户定义模块。

模块通过require函数提取。如果它是一个核心模块，那么参数仅仅是模块的名称。如果它是一个用户自定义模块，那么参数就是该模块在文件系统中的路径。例如：

// extract a core module like this
var http = require('http);
// extract a user defined module like this
var something = require('./folder1/folder2/folder3/something.js');

4.回调函数

在JavaScript中，函数被认为是第一类对象。这意味着你可以对这些函数做所有可对常规对象做的操作。你可以赋值函数给变量，作为参数传递函数给方法，作为对象属性声明函数，甚至从函数返回函数。

回调函数是JavaScript中的匿名函数，它可以作为参数传递给其他函数，要么被执行或返回自函数稍后执行。这是回调函数——这个使用最广的函数编程范式的基础。

当我们将回调函数作为参数传递给另一个函数的时候，我们只能传递函数定义……换言之就是，我们不知道这个回调函数什么时候会执行。这完全取决于调用函数的机制。它会在以后的某个时间点“回调”，因此而得名。这也是非阻塞或Node.js异步行为的唯一基础，如下例所示。

setTimeout(function() {
    console.log("world");
}, 2000)
console.log("hello");

这是回调函数最简单的例子之一。我们将一个匿名函数作为一个参数传递，这个参数只需在控制台上记录一些输出到setTimeout函数。它是唯一的函数定义，但是不知道何时执行。这需要经过2秒后，通过第二个参数，调用setTimeout函数来决定。

首先，第二个日志语句记录输出到控制台，然后，2秒钟后，回调函数中的日志语句记录输出。

// output
hello
world

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