Einführung in die Kapselung in JavaScript
JavaScript ist eine robuste objektorientierte Skriptsprache, mit der komplexe Anwendungen sowohl auf dem Client als auch auf dem Computer erstellt werden können der Kellner. Je komplexer die Implementierung ist, desto besser ist der wartbare und flexible Code, um die Situation zu bewältigen. Die Kapselung, eines der Prinzipien der objektorientierten Programmierung, ist der Schlüssel zum Erreichen solcher Ziele.
Die Kapselung in JavaScript ist per Definition ein Prozess, bei dem die Daten mit den Funktionen verknüpft werden, die auf die Daten wirken. Durch die Kapselung können wir die Daten kontrollieren und validieren. In JavaScript ähneln Variablen Daten.
Kapselung bedeutet das Verbergen von Informationen, dh die Idee, dass die internen Entitäten eines Objekts nicht direkt als öffentliche Entitäten entblößt werden sollten. Dies hilft, die nicht autorisierte Verwendung der Variablen einzuschränken. Wenn die Aufrufer ein definiertes Ergebnis erzielen möchten, sollten sie stattdessen die öffentliche Methode oder öffentliche Entitäten im Objekt verwenden, um auf die privaten Variablen des Objekts zuzugreifen.
Funktionsweise der Kapselung in JavaScript
Nehmen wir ein einfaches Problem, bei dem ein "Mitarbeiter" -Objekt zwei Attribute "Name" -Attribut enthält.
var employee = (
name : "Aditya Chaturvedi",
);
alert(employee.name); // Aditya Chaturvedi
employee.name = "Rahul Khanna";
alert(employee.name); // Rahul Khanna
Im obigen Beispiel sieht alles gut aus. Wir haben das Objekt erstellt, seinen Attributwert gedruckt und geändert. Das Problem scheint jedoch aufzutreten, wenn ein Benutzer versucht, dem Attribut name einen ganzzahligen Wert zuzuweisen.
employee.name = "Amit Trivedi";
alert(employee.name); // Amit Trivedi
Für JavaScript ist dies völlig legal, da eine Variable in JavaScript jeden Typ annehmen kann, der ihr zugewiesen wurde. Um dies zu korrigieren, müssen wir den Bereich gültiger Zeichen festlegen, der auf den Attributnamen des Objekts gesetzt werden kann. Diese Überprüfungen können nicht ausgeführt werden, wenn der Anrufer auf den Wert dieser Daten zugreifen und diesen ändern kann. Die einfache Lösung dafür wäre
var employee = (
name : "Aditya Chaturvedi",
setName : function (value) (
var exp = new RegExp(/\d+/);
if( exp.test(value) ) (
alert("Invalid Name");
)
else (
this.name = value;
)
),
"getName" : function() (
return this.name;
)
);
alert( employee.getName() ); // Aditya Chaturvedi
employee.setName( "Rahul Khanna" );
alert( employee.getName() ); // Rahul Khanna
employee.setName( 42 ); // Invalid Name
alert( employee.getName() ); // Rahul Khanna
Das obige Beispiel wendet die Validierung an, weist jedoch weiterhin einige Fehler auf, als ob der Anrufer direkt auf den Namen zugreifen und ihn dennoch ändern kann.
employee.setName( 42 ); // Invalid Name; Here name won't be changed.
employee.name = 42; // No validation happens and the name is changed
alert( employee.getName() ); // 42 is printed.
Das Endziel hier ist, dass der Variablenname nicht global mit dem Objekt "Mitarbeiter" verfügbar sein sollte. Die Kapselung hilft dabei. Dies kann durch die Konzepte Funktionsumfang und Abschlüsse gelöst werden.
1. Funktionsumfang
Jede Variable, die in den Codeblock der Funktionen geschrieben wird, bleibt von außen verborgen.
function fnScope()
(
var fnVar = "Hi!";
alert( fnVar ) // "Hi!";
)
alert( fnVar ) // error; fnVar is not accessible outside the function.
Wenn wir also die Variable "name" innerhalb der Funktion "setName" verschieben, können die Aufrufer nicht direkt darauf zugreifen. Es ist jedoch nicht einfach, die Variable "name" direkt in die Funktion "setName" einzufügen, da die Variable innerhalb eines Funktionsblocks nicht außerhalb ihres Gültigkeitsbereichs verwendet werden kann. Daher wäre name für die Methode "getName" nicht verfügbar. Hierfür hilft Closure.
2. Verschlüsse
Wenn zwei Funktionen zusammen mit Verweisen auf ihren Umgebungszustand oder die lexikalische Umgebung gebündelt werden, spricht man von einem Abschluss. Mit einfachen Worten, Closure ermöglicht den Zugriff auf eine lokale Variable einer Funktion, die von einer anderen Funktion in einer übergeordneten Funktion verwendet werden soll. Hier haben wir einen Variablennamen, der sich innerhalb der Funktion setName von der Außenwelt versteckt. Aber das innere Objekt (myObj) kann darauf zugreifen:
var employee = function () (
var name = "Aditya Chaturvedi";
var exp = new RegExp(/\d+/);
var myObj = (
setName : function (value) (
if( exp.test(value) ) (
alert("invalid name");
)
else (
name = value; // The object has access to "name"
)
),
getName : function () (
return name; // The object has access to "name"
)
); // End of the Object
);
employee.getName(); // doesn't work!
Jetzt haben wir das Konzept der Schließung verwendet, auf das innere Objekt myObj können beide Funktionen zugreifen. Trotzdem liegt ein Fehler beim Zugriff auf das innere Objekt vor. Oben haben wir gesehen, dass employee.getName nicht verwendet werden kann, und employee.myObj.getName kann auch nicht verwendet werden, da myObj auch für die Funktion privat ist und auf private Variablen nicht wie folgt von außen zugegriffen werden kann. Daher müssen wir das innere Objekt immer dann zurückgeben, wenn die anonyme Funktion aufgerufen wird, und es einer externen Variablen zuweisen.
var employee = function () (
var name = "Aditya Chaturvedi";
var exp = new RegExp(/\d+/);
return (
setName : function (value) (
if( exp.test(value) ) (
alert("Invalid Name");
)
else (
name = value;
)
),
getName : function () (
return name;
)
); // end of the return
)(); // Note this '()' means we're calling the function
// and assigning the returned value to the variable employee
alert(employee.getName()); // Aditya Chaturvedi
employee.setName( "Rahul Khanna" );
alert(employee.getName()); // Rahul Khanna
employee.setName( 42 ); // Invalid Name; the name does'nt changes.
employee.name = 42; // Doesn't affect the private fullName variable.
alert(employee.getName()); // Rahul Khanna is printed again.
Vorteile der Kapselung in JavaScript
Der Hauptvorteil der Verwendung der Kapselung in JavaScript besteht in der Gewährleistung der Datensicherheit. Weitere Vorteile der Verkapselung sind:
- Die Kapselung schützt ein Objekt vor illegalem Zugriff.
- Die Kapselung hilft dabei, ein Level zu erreichen, ohne die komplexen Details preiszugeben.
- Dies wird menschliche Fehler reduzieren.
- Machen Sie die Anwendung flexibler und verwaltbarer.
- Vereinfacht die Anwendung.
Fazit
Encapsulation ist das Tool in JavaScript, das verwendet werden kann, um die komplexe Operation einfach und übersichtlich zu gestalten und die gesamte Anwendung sicher und einfach zu bedienen.
Empfohlene Artikel
Dies ist eine Anleitung zur Kapselung in JavaScript. Hier diskutieren wir die Arbeitsweise der Kapselung in Javascript zusammen mit Konzepten und Vorteilen. Sie können sich auch die folgenden Artikel ansehen, um mehr zu erfahren.
- Funktionen von JavaScript (Kommentare)
- Arrays in JavaScript - Typen und Methoden
- JavaScript-Werkzeuge
- Für Schleife in JavaScript (Workflow)
- Variablen in JavaScript
- Typen und Fehlerbehandlung in JavaScript
- Regex-Funktionen in Python (Beispiel)
- Beispiele für Kommentare in PHP