Ultimate Guide to Getters és Setters a JavaScript-ben
getter és alkotóinak funkciók vagy módszerek kap és készlet a változók értékei. A getter-szetter koncepció gyakori a számítógépes programozásban: szinte minden magas szintű programozási nyelv egy szintaxis-készletet tartalmaz a getterek és az elrendezők megvalósításához, beleértve a JavaScipt-et..
Ebben a bejegyzésben meglátjuk, hogy milyen getterek vannak, és hogyan létrehozza és használhatja őket a JavaScript-ben.
Getters-setters és kapszulázás
Mindig megemlítik a getterek és az elrendezők ötletét kapszulázással együtt. A kapszulázás lehet kétféleképpen értik.
Először is, ez a létrehozása data-getter-alkotóinak a trió az adatok eléréséhez és módosításához. Ez a meghatározás akkor hasznos, ha bizonyos műveleteknek, mint például az érvényesítésnek az adatokon az elmentők mentése vagy megnézése előtt a rendezők tökéletes otthont adnak neki.
Másodszor, van egy szigorúbb definíció, amely szerint a kapszulázás történik az adatok elrejtése, hogy más kódból hozzáférhetetlen legyen, kivéve a gettereken és a rendezőkön keresztül. Így nem érünk véghez véletlenül felülírja a fontos adatokat más programkóddal.
Készítsen gettert és beállítókat
1. Módszerek
Mivel a getterek és a rendezők alapvetően működik hogy az értéket be- és / vagy módosít többféle módon létrehozni és használni őket. Az első út:
var obj = foo: 'ez a foo értéke, getFoo: function () return this.foo; , setFoo: függvény (val) this.foo = val; console.log (obj.getFoo ()); // "ez a foo értéke" obj.setFoo ('hello'); console.log (obj.getFoo ()); // "Szia" Ez a legegyszerűbb mód getters és seters létrehozása. Van egy ingatlan ize és két módszer létezik: getFoo és setFoo nak nek visszatérés és érték hozzárendelése az ingatlanhoz.
2. Kulcsszavakkal
Még több “hivatalos” és a getterek és a letelepítők létrehozásának robusztus módja a kap és készlet kulcsszavak.
Nak nek hozzon létre egy getteret, helyezze a kap kulcsszó egy függvénynyilatkozat előtt, amely getter módszerként szolgál, és használja a készlet kulcsszó azonos módon hozzon létre egy szetteret. A szintaxis a következő:
var obj = fooVal: 'ez a foo értéke, get foo () return this.fooVal; , set foo (val) this.fooVal = val; console.log (obj.foo); // "ez a foo értéke" obj.foo = 'hello'; console.log (obj.foo); // "Szia"
Ne feledje, hogy az adatok csak egy tulajdonságnév alatt tárolható (fooVal) ez különböző a getter-szetter módszerek nevéből (ize), mert a getter-szetteret tartó ingatlan nem tudja megtartani az adatokat is.
Melyik út jobb?
Ha úgy dönt, hogy kulcsszavakat hoz létre és beállít, akkor a hozzárendelési operátor az adatok beállításához és a pont operátor, hogy megkapja az adatokat, ugyanúgy, mint egy rendszeres tulajdonság értékét elérné / beállítaná.
Ha azonban a getters és a seters első kódolásának módját választja, a szetter és a getter módszereket kell hívnia a függvényhívó szintaxis használatával mert tipikus funkciók (semmi különös, mint a kap és készlet kulcsszavak).
Emellett esély van arra is, hogy véletlenül eljön más érték hozzárendelése azoknak a tulajdonságoknak, amelyek ezeket a getter-szetter módszereket \ t teljesen elveszítik! Valami, amit nem kell aggódnia a későbbi módszerben.
Szóval, láthatjuk, hogy miért mondtam a második technika erősebb.
Felülírja a megelőzést
Ha valamilyen oknál fogva az első technikát részesíti előnyben, készítse el a getter-setter módszereket csak olvasható létrehozásával használva Object.defineProperties. A létrehozott tulajdonságok Object.defineProperties, Object.defineProperty és Reflect.defineProperty automatikusan konfigurálható nak nek írható: hamis ami azt jelenti csak olvasható:
/ * A felülírás felülírása * / var obj = foo: 'ez a foo' értéke; Object.defineProperties (obj, 'getFoo': value: function () return this.foo;, 'setFoo': value: function (val) this.foo = val;); obj.getFoo = 66; // getFoo nem lesz felülírva! console.log (obj.getFoo ()); // "ez a foo értéke"
Műveletek a getters és az elrendezők között
Miután bevezette a getters-et és a seters-t, előreléphetsz műveletek végrehajtása az adatokon mielőtt megváltoztatná vagy visszaküldi.
Az alábbi kódban a getter függvényben az adatok vannak összefűzve egy sztringgel visszaadás előtt, és a szetter funkcióban a az érték szám vagy nem frissítés előtt n.
var obj = n: 67, get id () return 'Az azonosító:' + this.n; , set id (val) if (val === 'szám') ez.n = val; console.log (obj.id); // "Az ID: 67" objekt.id = 893; console.log (obj.id); // "Az azonosító: 893" obj.id = 'hello'; console.log (obj.id); // "Az azonosító: 893"
Védje az adatokat getterekkel és beállításokkal
Eddig a kapszulázás első kontextusában lefedtük a getterek és az elrendezők használatát. Lépjünk a másodikra, azaz hogyan kell a külső kódból származó adatok elrejtése getterek és rendezők segítségével.
Nem védett adatok
A getterek és a letelepedők felállítása nem jelenti azt, hogy az adatok csak ezeken a módokon érhetők el és módosíthatók. A következő példában ez közvetlenül megváltozott anélkül, hogy megérintené a getter és szetter módszereket:
var obj = fooVal: 'ez a foo értéke, get foo () return this.fooVal; , set foo (val) this.fooVal = val; obj.fooVal = 'hello'; console.log (obj.foo); // "Szia"
Nem használtuk a szetteret közvetlenül megváltoztatta az adatokat (fooVal). Azok az adatok, amelyeket eredetileg beállítottunk obj elment most! Ennek megakadályozására (véletlenül) némi védelemre van szükség adatait. Ezt hozzáadhatja a hatály korlátozása az adatok elérhetősége. Ezt teheted meg blokk méretezés vagy függvény meghatározása.
1. Blokkolás meghatározása
Az egyik módja az használjon blokk hatókört amelyen belül az adatokat a enged kulcsszó, amely korlátozza annak hatályát a blokkhoz.
A blokk hatóköre létrehozható a kód behelyezésével belsejében egy pár göndör nadrágtartó. Amikor létrehoz egy blokkkört, győződjön meg róla, hogy Szólj hozzá fölött azt kérte, hogy a nadrágtartó egyedül maradjon, hogy senki ne legyen eltávolítja a zárójeleket véletlenül úgy gondolták, hogy néhány extra redundáns zárójel a kódban vagy címkét a blokk hatóköréhez.
/ * BLOCK SCOPE, hagyja egyedül a zárójeleket! * / let fooVal = 'ez a foo értéke; var obj = get foo () return fooVal; , állítsa be a foo (val) fooVal = val fooVal = 'hello'; // nem fogja befolyásolni a fooVal-t a blokkkonzolon .log (objekt.foo); // "ez a foo értéke"
Megváltoztatása / létrehozása fooVala blokkon kívül nem befolyásolja a fooVal a getters-elrendezőkben.
2. Funkcióméretezés
A legszélesebb módja az adatoknak az alkalmazási körrel való védelme az adatok egy funkción belüli megtartása és egy objektum visszajuttatása a getterekkel és a beállítókkal.
funkció myobj () var fooVal = 'ez a foo értéke; return get foo () return fooVal; , állítsa be a foo (val) fooVal = val fooVal = 'hello'; // nem befolyásolja az eredeti fooVal var obj = myobj (); console.log (obj.foo); // "ez a foo értéke"
Az objektum (a ize () getter-setter belsejében), amelyet a myobj () funkció mentve obj, és akkor obj régebben hívja a getteret és a szetteret.
3. Adatvédelem alkalmazási kör nélkül
Van egy másik módja is, hogy megvédje az adatait a felülírástól korlátozása nélkül. A mögötte levő logika így megy: hogyan változtathat meg egy adatot, ha nem tudja, mi az, amit hívnak?
Ha az adatok a nem olyan könnyen reprodukálható változó / tulajdonságnév, az esélye, hogy senki sem (még magunk is) végül felülírja azt azzal, hogy bizonyos értéket rendel a változó / tulajdonság nevéhez.
var obj = s89274934764: 'ez a foo értéke, get foo () return this.s89274934764; , set foo (val) this.s89274934764 = val; console.log (obj.foo); // "ez a foo értéke"
Nézze, ez az egyik módja annak, hogy dolgozzon ki. Bár az általam választott név nem igazán jó, akkor is véletlenszerű értékeket vagy szimbólumokat használjon hogy hozzon létre tulajdonosneveket, amint azt Derick Bailey javasolta ebben a blogbejegyzésben. A fő cél az, hogy tartsa az adatokat rejtve más kódból, és hagyja, hogy a getter-seter pár hozzáférjen / frissítse azt.
Mikor használjon gettert és beállítókat?
Most jön a nagy kérdés: elkezdi-e hozzárendelni a gettert és a beállítókat adatait Most?
Ha te az adatok elrejtése, akkor ott van nincs más választás.
De ha az Ön által más kódban látott adatok rendben vannak, akkor még mindig használnia kell getters-t csak hogy kódoljon mely műveleteket hajt végre rajta? mondanám Igen. Kód nagyon hamar hozzáad. Az egyedi adatok mikroegységeinek létrehozása saját getter-seterrel bizonyos függetlenséget biztosít Önnek az említett adatokra, a kód más részeinek befolyásolása nélkül.
