Inleiding tot inkapseling in JavaScript
JavaScript is een robuuste objectgeoriënteerde scripttaal, waarmee complexe applicaties op de client en kunnen worden gebouwd de server. Hoe hoger de complexiteit bij de implementatie, hoe beter onderhoudbaar en flexibel code nodig is om de situatie aan te pakken. Inkapseling, een van de principes van objectgeoriënteerd programmeren, is de sleutel om dergelijke doelen te bereiken.
Per definitie is inkapseling in JavaScript een proces waarbij de gegevens worden gekoppeld aan de functies die op de gegevens werken. Met inkapseling kunnen we de gegevens beheren en valideren. In JavaScript lijken variabelen op gegevens.
Inkapseling betekent het verbergen van informatie, dwz het idee dat de interne entiteiten van een object niet direct als publieke entiteiten mogen worden blootgelegd. Dit helpt het ongeautoriseerde gebruik van de variabelen te beperken. Als de bellers een bepaald resultaat willen bereiken, moeten ze in plaats daarvan de openbare methode of openbare entiteiten in het object gebruiken om toegang te krijgen tot de privévariabelen van het object.
Werken van inkapseling in JavaScript
Laten we een eenvoudig probleem nemen waarbij een "medewerker" -object twee attributen "name" kenmerk bevat.
var employee = (
name : "Aditya Chaturvedi",
);
alert(employee.name); // Aditya Chaturvedi
employee.name = "Rahul Khanna";
alert(employee.name); // Rahul Khanna
Alles ziet er goed uit in het bovenstaande voorbeeld. We hebben het object gemaakt, de kenmerkwaarde afgedrukt en gewijzigd. Maar het probleem lijkt zich voor te doen wanneer een gebruiker probeert een geheel getal in te stellen voor het kenmerk name.
employee.name = "Amit Trivedi";
alert(employee.name); // Amit Trivedi
Wat JavaScript betreft, is dit volkomen legaal omdat in JavaScript een variabele elk type kan accepteren dat eraan wordt gegeven. Om dit te corrigeren, moeten we het bereik van geldige tekens instellen dat kan worden ingesteld op de kenmerknaam van het object. Deze validaties kunnen niet werken als de beller toegang heeft tot de waarde van deze gegevens en deze kan wijzigen. De eenvoudige oplossing hiervoor zou zijn
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
Het bovenstaande voorbeeld past de validatie toe, maar heeft nog steeds enkele fouten alsof de beller rechtstreeks toegang heeft tot de naam, hij kan deze nog steeds wijzigen.
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.
Het einddoel hier is dat de variabelenaam niet wereldwijd beschikbaar moet zijn met het object 'medewerker'. Inkapseling helpt het. Dit kan worden opgelost door de concepten Function Scope en Closures.
1. Functiebereik
Elke variabele die in het codeblok van de functies wordt geschreven, blijft van buitenaf verborgen.
function fnScope()
(
var fnVar = "Hi!";
alert( fnVar ) // "Hi!";
)
alert( fnVar ) // error; fnVar is not accessible outside the function.
Dus als we de variabele "name" binnen de functie "setName" verplaatsen, hebben de bellers er geen rechtstreeks toegang toe. Maar het is niet eenvoudig om de variabele "name" rechtstreeks in de functie "setName" te plaatsen, omdat de variabele in een functieblok niet buiten het bereik kan worden gebruikt, vandaar dat name niet beschikbaar zou zijn voor de methode "getName". Hiervoor zal Closure helpen.
2. Sluitingen
Wanneer twee functies worden gebundeld met verwijzingen naar hun omringende toestand of de lexicale omgeving bekend staat als een sluiting. Kort gezegd geeft sluiting toegang tot een lokale variabele van een functie die door een andere functie binnen een bovenliggende functie moet worden gebruikt. Hier hebben we een variabelenaam die zich binnen de functiesetName voor de buitenwereld verstopt. Maar het innerlijke object (myObj) heeft er toegang toe:
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!
Nu we het concept van sluiting hebben gebruikt, is het binnenobject myObj toegankelijk voor beide functies. Maar toch is er een fout om toegang te krijgen tot het innerlijke object. Hierboven hebben we gezien dat employee.getName niet kan worden gebruikt, noch employee.myObj.getName kan worden gebruikt, omdat myObj ook privé is voor de functie en privévariabelen niet buiten deze toegankelijk zijn. Daarom moeten we het binnenste object retourneren wanneer de anonieme functie wordt aangeroepen en aan een externe variabele toewijzen.
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.
Voordelen van inkapseling in JavaScript
Het belangrijkste voordeel van het gebruik van inkapseling in JavaScript is om de gegevens te beveiligen. Andere voordelen van inkapseling zijn onder meer:
- Inkapseling beschermt een object tegen illegale toegang.
- Inkapseling helpt om een niveau te bereiken zonder de complexe details te onthullen.
- Dit zal menselijke fouten verminderen.
- Maak de applicatie flexibeler en beter beheersbaar.
- Vereenvoudigt de toepassing.
Conclusie
Inkapseling is de tool in JavaScript die kan worden gebruikt om de complexe operatie eenvoudig en beheersbaar te maken, waardoor de algemene applicatie veilig en gemakkelijk te werken is.
Aanbevolen artikelen
Dit is een gids voor inkapseling in JavaScript. Hier bespreken we de werking van inkapseling in javascript samen met concepten en voordelen. U kunt ook de volgende artikelen bekijken voor meer informatie-
- Functies van JavaScript (opmerkingen)
- Arrays in JavaScript - Typen en methoden
- JavaScript-hulpmiddelen
- For Loop in JavaScript (workflow)
- Variabelen in JavaScript
- Typen en verwerkingsfouten in JavaScript
- Regex-functies in Python (voorbeeld)
- Voorbeelden van opmerkingen in PHP