Bevezetés a beágyazásba a JavaScript-ben
A JavaScript erős objektum-orientált szkriptnyelv, amely képes összetett alkalmazásokat létrehozni mind az ügyfélen, mind a klienseken a szerver. Minél azonban a végrehajtás összetettebb, annál jobb karbantarthatóságot és rugalmasságot igényel a helyzet megoldása. A beágyazás, az objektum-orientált programozás egyik alapelve kulcsa az ilyen célok elérésének.
A meghatározás szerint a beágyazás a JavaScript-be az az eljárás, amely az adatokat az adatokra ható funkciókkal köti. A beágyazás lehetővé teszi számunkra az adatok ellenőrzését és érvényesítését. A JavaScript-ben a változók az adatokra hasonlítanak.
A beágyazás az információ elrejtését jelenti, azaz azt az elképzelést, hogy egy objektum belső entitásai nem szabad közvetlenül nyilvánosakként megjelenni. Ez elősegíti a változók jogosulatlan felhasználásának korlátozását. Ehelyett, ha a hívó fél meghatározott eredményt akar elérni, akkor az objektumon belüli nyilvános módszert vagy nyilvános entitásokat kell használnia az objektum privát változóinak eléréséhez.
A beágyazás működése a JavaScript-ben
Vegyünk egy egyszerű problémát, ahol egy „alkalmazott” objektum két „name” attribútumot tartalmaz.
var employee = (
name : "Aditya Chaturvedi",
);
alert(employee.name); // Aditya Chaturvedi
employee.name = "Rahul Khanna";
alert(employee.name); // Rahul Khanna
A fenti példában minden jól néz ki. Készítettük az objektumot, kinyomtattuk az attribútum értékét és módosítottuk. De úgy tűnik, hogy a probléma akkor merül fel, amikor egyes felhasználók megpróbálnak egész értéket beállítani a név attribútumra.
employee.name = "Amit Trivedi";
alert(employee.name); // Amit Trivedi
Ami a JavaScript-et illeti, ez teljesen törvényes, mivel a JavaScript-ben a változó bármilyen típusú fájlt elfogadhat. Ennek kijavításához be kell állítanunk az érvényes karakterek tartományát, amelyek beállíthatók az objektum attribútumnevéhez. Ezek az érvényesítések nem működnek, ha a hívó fél elérheti és módosíthatja ezen adatok értékét. Erre az egyszerű megoldás lenne
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
A fenti példa érvényesíti az érvényesítést, de még mindig vannak hibái, mintha a hívó közvetlenül elérné a nevet, mégis megváltoztathatja.
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.
A végcél itt az, hogy a változó neve nem elérhető globálisan az „alkalmazott” objektummal együtt. A kapszulázás segít abban. Ezt a Function Scope and Closures fogalmakkal oldhatjuk meg.
1. Funkció hatóköre
Bármely változó, amelyet a funkciók kódblokkjába írnak, kívülről rejtve marad.
function fnScope()
(
var fnVar = "Hi!";
alert( fnVar ) // "Hi!";
)
alert( fnVar ) // error; fnVar is not accessible outside the function.
Ezért ha a „name” változót a „setName” funkción belül mozgatjuk, akkor a hívók nem férnek hozzá közvetlenül. De ez nem könnyű közvetlenül a „name” változót a „setName” függvénybe helyezni, mivel a funkcióblokkban lévő változó nem használható a hatókörén kívül, ezért a „getName” módszerhez a név nem állna rendelkezésre. Ehhez a bezárás segít.
2. Zárások
Ha két funkciót összekapcsolunk a környező állapotukra vagy a lexikai környezetre való hivatkozással együtt, bezárásnak tekintjük. Egyszerű szavakkal: a bezárás hozzáférést biztosít egy függvény helyi változójához, amelyet egy másik funkció használhat a szülő funkción belül. Itt van egy változó név, amely a setName függvényben rejtőzik a külvilágtól. De a belső objektum (myObj) hozzáférhet hozzá:
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!
Most a bezárás fogalmát használtuk, a myObj belső objektum mindkét funkcióval elérhető. De továbbra is hibás a belső tárgy elérése. A fentiekben láthattuk, hogy a töötaja.getName nem használható, sem a töötaja.myObj.getName sem használható, mivel a myObj szintén magántulajdonban van a függvényhez, és a privát változók ilyen módon nem érhetők el. Ezért vissza kell adnunk a belső objektumot, amikor az anonim függvényt meghívjuk, és hozzá kell rendelnünk egy külső változóhoz.
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.
A beágyazás előnyei a JavaScript-ben
A JavaScript beágyazásának fő előnye az adatok biztonságának biztosítása. A beágyazás további előnyei a következők:
- A kapszula védi az objektumot az illegális hozzáférés ellen.
- A beágyazás segít elérni a szintet anélkül, hogy komplex részleteit feltárná.
- Ez csökkenti az emberi hibákat.
- Az alkalmazás rugalmasabbá és kezelhetőbbé tétele.
- Egyszerűsíti az alkalmazást.
Következtetés
A beágyazás a JavaScript alkalmazásának eszköze, amely felhasználható az összetett művelet egyszerű és kezelhetővé tételére, azáltal, hogy az általános alkalmazás biztonságos és könnyen kezelhető.
Ajánlott cikkek
Ez egy útmutató a Beágyazás JavaScript-hez. Itt megvitatjuk a javascript-be történő beágyazás működését, valamint fogalmakat és előnyöket. A következő cikkeket is megnézheti további információkért -
- A JavaScript tulajdonságai (megjegyzések)
- Tömbök a JavaScript-ben - típusok és módszerek
- JavaScript eszközök
- A hurok számára a JavaScript-ben (munkafolyamat)
- Változók a JavaScript-ben
- Típusok és kezelési hibák a JavaScript-ben
- Regex funkciók a Pythonban (példa)
- Példák a PHP megjegyzéseire