Arten von Namespaces in JavaScript

JavaScript “Namespace”Ist ein Programmierparadigma, das zur Zuweisung von Umfangsumfang an die Kennungen wie Variablen und Funktionsnamen verwendet wird. Es wird gewohnt Kollisionen verhindern zwischen den gleich benannten Variablen und Funktionen. Beispielsweise erfordert ein JavaScript -Programm das Erstellen der gleichen Namensvariablen in einem anderen Kontext. In dieser Situation nutzen “NamespaceIsoliert die Kontexte und ermöglicht es, dass der gleiche Kennung in anderen Namespaces verwendet werden kann.

In diesem Beitrag werden verschiedene Arten von Diskussionen erörtert Namespaces In JavaScript. So lass uns anfangen!

JavaScript -Namespace

Das Konzept des Hinzufügens von Klassen, Methoden, Variablen und Objekten in einem Container ist als "bekannt als"Namespace”In JavaScript. Der Code, den Sie in einem JavaScript -Programm und den vordefinierten Methoden schreiben, werden in der “gespeichert“Fenster"Variable, als" betrachtet "Globaler Namespace“. Dieser Fenster -Namespace wird verwendet, wenn eine neue Variable erstellt wird. Wenn Sie jeden Wert in der neu erstellten Variablen speichern. So funktioniert die Hierarchie in JavaScript.

Arten von Namespaces in JavaScript

JavaScript unterstützt zwei Arten von Namespaces:

• Statisch Namespace
• Dynamisch Namespace

Wir werden beide genannten Namespaces -Typen im Detail diskutieren.

Statischer Namespace in JavaScript

Wenn ein "Namespace -Etikett"Ist hartcodiert und eine Funktion ist darin definiert, sie ist als" bekannt "Statischer Namespace“. Es ermöglicht die Neuzuweisung der Namespaces; Ein statischer Namespace bezieht sich jedoch immer auf dieselben alten JavaScript -Objekte.

Die statischen Namespaces in JavaScript sind in die folgenden Kategorien unterteilt:

• Statischer Namespace mit Direkte Aufgabe
• Statischer Namespace mit Objekt wörtlicher Notation
• Statischer Namespace mit Modulmuster

Lassen Sie uns nun die Funktionalität jeder der angegebenen Arten des statischen Namespace verstehen.

Statischer Namespace mit direkter Zuordnung

In "Direkte Aufgabe”, Funktionen werden mit dem bereits erstellten statischen Namespace definiert. Zum Beispiel werden wir im folgenden Beispiel ein mit dem Namen namens “erstellen“Student,Das fungiert als statischer Namespace:

var student =

Danach werden wir zwei Funktionen definieren “GetName ()" Und "getage ()"Und verknüpfen sie mit dem" zusammen "StudentNamespace:

Student.getName = function ()
var name = "Alex";
Rückgabename;
Student.getage = function ()
var Alter = 35;
Rückkehralter;
Konsole.Protokoll (Student.GetName ());
Konsole.Protokoll (Student.getage ());

Als Funktionen werden direkt dem zugeordnetStudentNamespace, es führt zu der folgenden Ausgabe:

Statischer Namespace mit Objektliteralnotation

In dieser Art von statischer Namespace werden Funktionen innerhalb der hinzugefügt Namespace bei Objektdeklaration.

Im folgenden Programm haben wir das verwendet Objekt wörtlicher Notation einen statischen Namespace definieren “Student”Und fügen Sie die" hinzu "GetName ()" Und "getage ()”Funktion innerhalb seines Geltungsbereichs:

var student =
GetName: function ()
var name = "Alex";
Rückgabename; ,
Getage: function ()
var Alter = 35;
Rückkehralter;
;
Konsole.Protokoll (Student.GetName ());
Konsole.Protokoll (Student.getage ());

Ausgang

Statischer Namespace mit Modulmuster

Das JavaScript "Modulmuster”Verwendet a Funktionsumpackung Das kehrt zurück ein Objekt. Das zurückgegebene Objekt bezieht sich auf die Logik der öffentlichen Schnittstelle des Moduls im globalen Bereich.

Diese Art von statischer Namespace ruft die Funktion auf, speichert den zurückgegebenen Wert für die Namespace -Variable und sperrt die Modul -API in den Namenspace Scope. Die nicht im Rückgabewert enthaltenen Variablen werden privat gehalten und nur für die Funktion zugänglich, die sich auf sie bezieht.

Beispiel
Wir werden jetzt definieren “Student" Als ein statischer Namespace und wickeln Sie es in eine Funktion ein:

var student = (function ()
zurückkehren
GetName: function ()
var name = "Alex";
Rückgabename;
,
Getage: function ()
var Alter = 35;
Rückkehralter;

; ) ();
Konsole.Protokoll (Student.GetName ());
Konsole.Protokoll (Student.getage ());

Der Wert, der durch die zurückgegeben wirdGetName ()" Und "getage ()Methoden werden in der erstellten statischen Namespace -Variablen gespeichert:

Dynamischer Namespace in JavaScript

Anstatt ein Namespace -Etikett zu färben, ist eine “Dynamischer Namespace" Ist verwiesen innerhalb der Funktionsumpackung. Diese Art von Namespace beseitigt die Anforderung, den Rückgabewert zu kombinieren, um diese Werte dem definierten Namespace zuzuweisen. Es wird hauptsächlich in Situationen verwendet, in denen mehrere unabhängige Instanzen eines Moduls in verschiedenen Fällen erstellt werden.

Der dynamische Namespace kann in JavaScript durch Übergabe des Namespace als "StreitOder definieren es mit dem "anwenden" Stichwort.

Lassen Sie uns beide Verfahren nacheinander verstehen.

Dynamischer Namespace als Argument übergeben

JavaScript ermöglicht es Ihnen, a zu erstellen Dynamischer Namespace indem Sie es als eine vorübergehen Streit zum Selbstverständlichkeit. Diese Funktionen werden mit Hilfe des bestandenen Arguments definiert.

Zum Beispiel werden wir eine "erstellen"Student"Namespace und als Argument bestehen"std”. Danach werden wir die "definieren"GetName ()" Und "getage ()”Funktionen, indem sie die“ nutzen “std" Streit:

var student = ; (function (std)
std.getName = function ()
var name = "Alex";
Rückgabename;
;
std.getage = function ()
var Alter = 35;
Rückkehralter;

)(Student);
Konsole.Protokoll (Student.GetName ());
Konsole.Protokoll (Student.getage ());

Die Ausführung des oben gegebenen Programms zeigt die folgende Ausgabe an:

Erstellen dynamischer Namespace mit Schlüsselwort anwenden

Eine andere Methode, um a zu erstellen Dynamischer Namespace ist die Verwendung der “anwenden” Stichwort und geben Sie es als Argument vorbei. Danach fügen Sie die erforderlichen Funktionen mit dem hinzuDas" Stichwort.

Beispiel

var student = ; (function ()
Das.getName = function ()
var name = "Alex";
Rückgabename;
;
Das.getage = function ()
var Alter = 35;
Rückkehralter;

).bewerben (Student);
Konsole.Protokoll (Student.GetName ());
Konsole.Protokoll (Student.getage ());

Ausgang

Das waren alles wesentliche Informationen über die Typen von Namespaces In JavaScript. Sie können nach Bedarf recherchieren.

Abschluss

Der Statischer Namespace Typ Hardcodes Die Namespace -Etikett und definiert Funktionen innerhalb und die Dynamischer Namespace Typ ist verwiesen innerhalb der Funktionsumpackung. In JavaScript wird der statische Namespace mit direkter Zuordnung, Objektnotation und Modulmuster erstellt. Im Gegensatz dazu wird ein dynamischer Namespace definiert, indem es als Argument übergeben oder das Schlüsselwort anwenden. In diesem Beitrag wurde die Arten von Namespaces in JavaScript erörtert.