Въведение в капсулирането в JavaScript
JavaScript е здрав обектно-ориентиран скриптов език, който е в състояние да изгражда сложни приложения както на клиента, така и на сървърът. Въпреки това, колкото по-висока е сложността на внедряването, толкова по-добре поддържан и гъвкав код е необходим за справяне със ситуацията. Капсулирането, един от принципите на обектно-ориентираното програмиране, е ключът към постигането на такива цели.
По дефиниция Капсулирането в JavaScript е процес на обвързване на данните с функциите, които действат върху данните. Капсулацията ни позволява да контролираме и валидираме данните. В JavaScript променливите наподобяват данни.
Капсулирането означава скриване на информация, т.е. идеята, че вътрешните образувания на даден обект не трябва да бъдат пряко оголени като публични образувания. Това ще помогне за ограничаване на неоторизираната употреба на променливите. Вместо това, ако обаждащите се искат да постигнат определен резултат, той трябва да използва публичния метод или публичните субекти вътре в обекта за достъп до частните променливи на обекта.
Работа на капсулиране в JavaScript
Нека вземем един прост проблем, когато обектът „служител“ съдържа два атрибута „име“.
var employee = (
name : "Aditya Chaturvedi",
);
alert(employee.name); // Aditya Chaturvedi
employee.name = "Rahul Khanna";
alert(employee.name); // Rahul Khanna
Всичко изглежда добре в горния пример. Създадохме обекта, отпечатахме неговата стойност на атрибута и го променихме. Но проблемът изглежда възниква, когато някой потребител се опита да зададе целочислена стойност на атрибута име.
employee.name = "Amit Trivedi";
alert(employee.name); // Amit Trivedi
Що се отнася до JavaScript, това е напълно законно, тъй като в JavaScript променлива може да приеме всеки тип, предоставен му. За да коригираме това, трябва да зададем диапазона от валидни символи, които могат да бъдат зададени на името на атрибута на обекта. Тези проверки не могат да работят, ако обаждащият се има достъп и променя стойността на тези данни. Простото решение за това би било
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
Горният пример прилага валидирането, но все още има някои грешки, сякаш обаждащият се има достъп до името директно, той все още може да го промени.
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.
Крайната цел тук е, че името на променливата не трябва да е достъпно в глобален мащаб с обекта „служител“. Капсулирането му помага. Това може да бъде решено чрез концепциите Обхват на функция и затваряния.
1. Обхват на функцията
Всяка Променлива, която е написана вътре в кодовия блок на функциите, остава скрита отвън.
function fnScope()
(
var fnVar = "Hi!";
alert( fnVar ) // "Hi!";
)
alert( fnVar ) // error; fnVar is not accessible outside the function.
Следователно, ако преместим променливата „name“ във функцията „setName“, обаждащите се няма да имат достъп до нея директно. Но това не е лесно директно да поставите променливата „name“ във функцията „setName“, тъй като променливата във функционалния блок не може да се използва извън обхвата й, следователно името няма да е достъпно за метода „getName“. За това закриване ще помогне.
2. Затваряния
Когато две функции са групирани заедно с препратки към заобикалящото ги състояние или лексикалната среда е известна като затваряне. С прости думи, затварянето дава достъп до локална променлива на функция, която да се използва от друга функция в родителската функция. Тук имаме име на променлива, скриващо се във функцията setName от външния свят. Но вътрешният обект (myObj), може да получи достъп до него:
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!
Сега сме използвали концепцията за затваряне, вътрешният обект myObj може да бъде достъпен и от двете функции. Но все пак има грешка за достъп до вътрешния обект. По-горе видяхме служител.getName не може да се използва, нито служител.myObj.getName не може да се използва, тъй като myObj също е частен за функцията и частните променливи не могат да бъдат достъпни отвън като този. Следователно трябва да връщаме вътрешния обект, когато анонимната функция се извиква и да я присвояваме на външна променлива.
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.
Предимства на капсулирането в JavaScript
Основното предимство на използването на капсулиране в JavaScript е осигуряването на сигурност на данните. Други предимства на капсулацията включват:
- Капсулацията предпазва обект срещу незаконен достъп.
- Капсулацията помага да се постигне ниво, без да се разкриват сложните му детайли.
- Това ще намали човешките грешки.
- Направете приложението по-гъвкаво и управляемо.
- Опростява приложението.
заключение
Капсулирането е инструментът в JavaScript, който може да се използва, за да направи сложната операция лесна и управляема, като цялостното приложение е сигурно и лесно за работа.
Препоръчителни статии
Това е ръководство за капсулиране в JavaScript. Тук обсъждаме работата на капсулирането в JavaScript заедно с концепции и предимства. Можете също да разгледате следните статии, за да научите повече-
- Характеристики на JavaScript (Коментари)
- Масиви в JavaScript - типове и методи
- JavaScript инструменти
- За цикъл в JavaScript (работен поток)
- Променливи в JavaScript
- Видове и обработка на грешки в JavaScript
- Функции на Regex в Python (пример)
- Примери за коментари в PHP