Introduction à l'encapsulation en JavaScript
JavaScript est un langage de script orienté objet robuste, capable de créer des applications complexes à la fois sur le client et le serveur. Cependant, plus la complexité de la mise en œuvre est élevée, plus un code souple et maintenable est nécessaire pour faire face à la situation. L'encapsulation, l'un des principes de la programmation orientée objet, est la clé pour atteindre ces objectifs.
Par définition, l'encapsulation en JavaScript est un processus de liaison des données avec les fonctions qui agissent sur les données. L'encapsulation nous permet de contrôler et de valider les données. En JavaScript, les variables ressemblent à des données.
L'encapsulation signifie la dissimulation d'informations, c'est-à-dire l'idée que les entités internes d'un objet ne doivent pas être nues directement en tant qu'entités publiques. Cela contribuera à restreindre l'utilisation non autorisée des variables. Au lieu de cela, si les appelants souhaitent obtenir un résultat défini, ils doivent utiliser la méthode publique ou des entités publiques à l'intérieur de l'objet pour accéder aux variables privées de l'objet.
Fonctionnement de l'encapsulation en JavaScript
Prenons un problème simple où un objet "employé" contient deux attributs attribut "nom".
var employee = (
name : "Aditya Chaturvedi",
);
alert(employee.name); // Aditya Chaturvedi
employee.name = "Rahul Khanna";
alert(employee.name); // Rahul Khanna
Tout va bien dans l'exemple ci-dessus. Nous avons créé l'objet, imprimé sa valeur d'attribut et l'avons modifié. Mais le problème semble se poser lorsqu'un utilisateur essaie de définir une valeur entière pour l'attribut name.
employee.name = "Amit Trivedi";
alert(employee.name); // Amit Trivedi
En ce qui concerne JavaScript, cela est tout à fait légal car en JavaScript, une variable peut accepter tout type qui lui est donné. Pour corriger cela, nous devons définir la plage de caractères valides qui peuvent être définis sur le nom d'attribut de l'objet. Ces validations ne peuvent pas fonctionner si l'appelant peut accéder et modifier la valeur de ces données. La solution simple pour cela serait
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
L'exemple ci-dessus applique la validation mais a toujours quelques défauts comme si l'appelant accède directement au nom, il peut toujours le changer.
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.
L'objectif final ici est que le nom de la variable ne doit pas être disponible globalement avec l'objet «employé». L'encapsulation l'aide. Cela peut être résolu par les concepts Fonction Portée et fermetures.
1. Portée de la fonction
Toute variable écrite à l'intérieur du bloc de code des fonctions reste cachée de l'extérieur.
function fnScope()
(
var fnVar = "Hi!";
alert( fnVar ) // "Hi!";
)
alert( fnVar ) // error; fnVar is not accessible outside the function.
Par conséquent, si nous déplaçons la variable «nom» à l'intérieur de la fonction «setName», les appelants ne pourront pas y accéder directement. Mais ce n'est pas facile de mettre directement la variable "nom" dans la fonction "setName" car la variable à l'intérieur d'un bloc fonction ne peut pas être utilisée en dehors de sa portée, donc le nom ne serait pas disponible pour la méthode "getName". Pour cette fermeture, cela aidera.
2. Fermetures
Lorsque deux fonctions sont regroupées avec des références à leur état environnant ou l'environnement lexical est appelé fermeture. En termes simples, la fermeture donne accès à une variable locale d'une fonction à utiliser par une autre fonction à l'intérieur d'une fonction parent. Ici, nous avons un nom de variable caché à l'intérieur de la fonction setName du monde extérieur. Mais l'objet intérieur (myObj), peut y accéder:
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!
Maintenant que nous avons utilisé le concept de fermeture, l'objet interne myObj est accessible par les deux fonctions. Mais encore, il y a un défaut pour accéder à l'objet intérieur. Ci-dessus, nous avons vu que employee.getName ne peut pas être utilisé, ni employee.myObj.getName ne peut être utilisé car myObj est également privé de la fonction et les variables privées ne sont pas accessibles à l'extérieur comme ceci. Par conséquent, nous devons retourner l'objet interne chaque fois que la fonction anonyme est appelée et l'affecter à une variable externe.
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.
Avantages de l'encapsulation en JavaScript
Le principal avantage de l'utilisation de l'encapsulation en JavaScript est de sécuriser les données. Les autres avantages de l'encapsulation comprennent:
- L'encapsulation protège un objet contre tout accès illégal.
- L'encapsulation permet d'atteindre un niveau sans révéler ses détails complexes.
- Cela réduira les erreurs humaines.
- Rendre l'application plus flexible et gérable.
- Simplifie l'application.
Conclusion
L'encapsulation est l'outil en JavaScript qui peut être utilisé pour rendre l'opération complexe facile et gérable en rendant l'application globale sécurisée et facile à travailler.
Articles recommandés
Ceci est un guide d'encapsulation en JavaScript. Nous discutons ici du fonctionnement de l'encapsulation en javascript ainsi que des concepts et des avantages. Vous pouvez également consulter les articles suivants pour en savoir plus-
- Caractéristiques de JavaScript (Commentaires)
- Tableaux en JavaScript - Types et méthodes
- Outils JavaScript
- Pour boucle en JavaScript (Workflow)
- Variables en JavaScript
- Types et gestion des erreurs en JavaScript
- Fonctions Regex en Python (exemple)
- Exemples de commentaires en PHP