מדריך Getters ו סוחרים ב - JavaScript

Getters ו סוחרים הם פונקציות או שיטות המשמשות לקבל ו בחר את ערכי המשתנים. מושג גטר-סטר הוא נפוץ תכנות מחשבים: כמעט כל שפות תכנות ברמה גבוהה מגיעים עם סט של תחביר ליישם getters ו setters, כולל JavaScipt.

ב פוסט זה, נראה מה הם getters steers, וכיצד ליצור ולהשתמש בהם ב- JavaScript.

Getters-sters ו אנקפסולציה

הרעיון של getters ו sters תמיד מוזכר יחד עם אנקפסולציה. אנקפסולציה יכולה להיות הבין בשתי דרכים.

ראשית, היא הגדרת של נתונים- Getters- סטים כדי לגשת ולשנות את הנתונים. הגדרה זו שימושית כאשר יש לבצע פעולות מסוימות, כגון אימות, שבוצעו על הנתונים לפני שמירת או צפייה בו, getters ו setters לספק את הבית המושלם עבור זה.

שנית, יש הגדרה מחמירה יותר לפיה נעשה אנקפסולציה להסתיר נתונים, כדי להפוך אותו לקשה מקוד אחר, אלא באמצעות המכתבים והמתנחלים. בדרך זו אנחנו לא בסופו של דבר בטעות להחליף נתונים חשובים עם קוד אחר בתוכנית.

צור getters ו setters

1. בשיטות

מאז getters ו setters הם בעצם פונקציות כי לאחזר / לשנות ערך, יש יותר מדרך אחת ליצור ולהשתמש בהם. הדרך הראשונה היא:

 var obj = foo: 'זה הערך של foo', getFoo: function () Return this.foo; , setFoo: function (val) this.foo = val;  console.log (obj.getFoo ()); // "זה הערך של foo" obj.setFoo ('hello'); console.log (obj.getFoo ()); // "שלום"

זה הדרך הפשוטה ביותר כדי ליצור getters ו setters. יש נכס foo ויש שתי שיטות: getFoo ו setFoo ל לחזור ולהקצות ערך אל הנכס הזה.

2. עם מילות מפתח

עוד “רשמי” ואת דרך יציבה של יצירת getters ו setters היא באמצעות לקבל ו בחר מילות מפתח.

ל ליצור גטר, למקם את לקבל מילת מפתח לפני הצהרה פונקציה שישמש את שיטת גטר, ולהשתמש בחר מילת מפתח באותו אופן ליצור סטר. התחביר הוא כדלקמן:

 var obj = fooVal: 'זה הערך של foo', get foo () Return this.fooVal; , set foo (val) this.fooVal = val;  console.log (obj.foo); // "זה הערך של foo" obj.foo = 'hello'; console.log (obj.foo); // "שלום" 

שים לב שהנתונים יכולים להיות רק מאוחסן תחת שם המאפיין (fooVal) זה שונה משמו של שיטות גטר-סטר (foo) כי נכס מחזיק את גטר- setter לא יכול להחזיק את הנתונים גם כן.

איזו דרך טובה יותר?

אם אתה בוחר ליצור getters ו setters עם מילות מפתח, אתה יכול להשתמש מפעיל את המשימה כדי להגדיר את הנתונים וה אופרטור נקודה כדי לקבל את הנתונים, באותו אופן שבו ניגשת / הגדר את הערך של נכס רגיל.

עם זאת, אם תבחר את הדרך הראשונה של קידוד getters ו setters, אתה צריך לקרוא את המתקן ו getter שיטות באמצעות תחביר קריאה לפונקציה כי הם אופייניים פונקציות (שום דבר מיוחד כמו אלה שנוצרו באמצעות לקבל ו בחר Andrew.

כמו כן, יש סיכוי שאתה עלול בסופו של דבר בטעות להקצות ערך אחר את התכונות שהחזיקו אלה גטר- setter שיטות ו לאבד אותם לחלוטין! משהו שאתה לא צריך לדאוג בשיטה מאוחרת יותר.

אז, אתה יכול לראות למה אמרתי את זה הטכניקה השנייה היא חזקה יותר.

מחק את המניעה

אם מסיבה כלשהי אתה מעדיף את הטכניקה הראשונה, להפוך את המאפיינים להחזיק את גטר- setter שיטות לקריאה בלבד על ידי יצירתם באמצעות אובייקטים. מאפיינים שנוצרו באמצעות אובייקטים, חפץ ו Reflect.define נכס באופן אוטומטי להגדיר ל writable: שקר אשר אומר לקריאה בלבדYou

 / * מניעת כתיבה * / var obj = foo: 'זה הערך של foo'; Object.defineProperties (obj, 'getFoo': value: function () return this.foo;, 'setFoo': value: function (val) this.foo = val;; obj.getFoo = 66; / getFoo לא הולך להיות מוחלף! console.log (obj.getFoo ()); // "זה הערך של foo" 

פעולות בתוך Getters ו sters

ברגע שיש לך הציג את getters ו setters, אתה יכול ללכת קדימה לבצע פעולות על הנתונים לפני שינוי או החזרתו.

בקוד להלן, בפונקציה גטר הנתונים משורשר עם מחרוזת לפני שהוא מוחזר, ובפונקציה של סטר אימות של אם הערך הוא מספר או לא מבוצע לפני עדכון n.

 var obj = n: 67, get id () Return 'מזהה הוא:' + this.n; , קבע מזהה (val) if (typeof val === 'מספר') this.n = val;  console.log (obj.id); // "התעודה היא: 67" obj.id = 893; console.log (obj.id); // "התעודה היא: 893" obj.id = 'hello'; console.log (obj.id); // "התעודה היא: 893" 

הגנה על נתונים עם getters ו setters

עד כה, כיסינו את השימוש getters ו setters בהקשר הראשון של אנקפסולציה. בוא נעבור על השני, כלומר איך להסתיר נתונים מקוד חיצוני עם עזרה של getters ו setters.

נתונים לא מוגנים

ההגדרה של getters ו setters לא אומר את הנתונים ניתן לגשת ושינה רק באמצעות שיטות אלה. בדוגמה הבאה, זה שונה ישירות מבלי לגעת בשיטות הגטר והסטטר:

 var obj = fooVal: 'זה הערך של foo', get foo () Return this.fooVal; , set foo (val) this.fooVal = val;  obj.fooVal = 'hello'; console.log (obj.foo); // "שלום" 

לא השתמשנו בסטר ישירות שינו את הנתונים (fooVal). הנתונים שאנחנו בתחילה להגדיר בתוך obj הוא נעלם עכשיו! כדי למנוע זאת (בטעות), אתה צריך קצת הגנה עבור הנתונים שלך. אתה יכול להוסיף את זה על ידי הגבלת היקף שבו הנתונים שלך זמינים. אתה יכול לעשות את זה על ידי אחד בלוק סקופ או פונקציה scoping.

1. לחסום scoping

דרך אחת היא להשתמש בהיקף בלוק שבתוכו יוגדרו הנתונים באמצעות תן אשר מגבילה את היקפה לבלוק ההוא.

א היקף החסימה ניתן ליצור על ידי הצבת הקוד שלך בתוך זוג פסים מסולסלים. בכל פעם שאתה יוצר טווח לחסום הקפד השאר תגובה מעל זה מבקש את הפלטה להישאר לבד, כך שאף אחד מסיר את הפלטה בטעות לחשוב שהם כמה פלטה מיותר נוסף בקוד או הוסף תווית אל היקף החסימה.

 / * BLOCK SCOPE, לעזוב את הפלטה לבד! * / let fooVal = 'זה הערך של foo'; var obj = get foo () return fooVal; , הגדר foo (val) fooVal = val fooVal = 'hello'; / / לא הולך להשפיע על fooVal בתוך הבלוק console.log (obj.foo); // "זה הערך של foo"

שינוי / יצירה fooValמחוץ לבלוק לא ישפיע ה fooVal התייחס בתוך המתנחלים getters.

2. פונקציה scoping

הדרך הנפוצה יותר להגן על הנתונים עם סקופ היא על ידי שמירה על הנתונים בתוך פונקציה ו החזרת אובייקט עם getters ו setters מן הפונקציה.

 function myobj () var fooVal = 'זה הערך של foo'; Return get foo () return fooVal; , הגדר foo (val) fooVal = val fooVal = 'hello'; / / לא הולך להשפיע fovVal ​​המקורי שלנו ob obj = myobj (); console.log (obj.foo); // "זה הערך של foo"

האובייקט (עם foo () גטר-סטר בתוכו) חזר על ידי myobj () פונקציה נשמר ב obj, ואז obj רגיל ל לקרוא את גטר ואת סטר.

3. הגנה על נתונים ללא סקופ

יש גם דרך אחרת תוכל להגן על הנתונים שלך מלהיות מוחלפים מבלי להגביל את היקפה. ההיגיון מאחורי זה הולך ככה: איך אתה יכול לשנות פיסת נתונים אם אתה לא יודע מה נקרא?

אם הנתונים יש לא כל כך בקלות לשחזור משתנה / שם הנכס, רוב הסיכויים שאף אחד (אפילו את עצמנו) הוא הולך בסופו של דבר על ידי אותו על ידי הקצאת ערך כלשהו זה משתנה / שם הנכס.

 var obj = s89274934764: 'זה הערך של foo', get foo () Return this.s89274934764; , set foo (val) this.s89274934764 = val;  console.log (obj.foo); // "זה הערך של foo" 

תראי, זאת דרך אחת לעבוד על דברים. למרות השם שבחרתי הוא לא ממש טוב, אתה יכול גם השתמש בערכים או בסמלים אקראיים כדי ליצור שמות המאפיינים כפי שהיא מוצעת על ידי Derick Biley בבלוג זה. המטרה העיקרית היא לשמור את הנתונים מוסתרים מקוד אחר ולתת זוג גטר גטר לגשת / לעדכן אותו.

כאשר אתה צריך להשתמש getters ו setters?

עכשיו מגיע את השאלה הגדולה: אתה מתחיל הקצאת getters ו setters על כל הנתונים שלך עכשיו?

אם אתה הסתרת נתונים, אז יש אין ברירה אחרת.

אבל אם הנתונים שלך להיראות על ידי קוד אחר הוא בסדר, אתה עדיין צריך להשתמש getters סטרס רק כדי להרכיב אותו עם קוד שמבצע כמה פעולות על זה? הייתי אומר כן. קוד מוסיף מהר מאוד. יצירת יחידות מיקרו של נתונים בודדים עם גטר גטר משלה מספק לך עצמאות מסוימת לעבוד על נתונים אלה מבלי להשפיע על חלקים אחרים של הקוד.