במדריך זה נראה את ההיבטים של מגבלות ופונקציות הקשורות ל- hasOwnProperty() שיטה ב-JavaScript. נלמד גם על יישומיו והשימוש בו במדורים.

מבוא

ב JavaScript , שיטת hasOwnProperty() מוגדרת כמאפיין כדי להבטיח אם האובייקט שייך לפרויקט שהוזכר או לא. אם יימצא שהמאפיין שייך לאובייקט מוכר, הוא יחזיר פלט מבוסס משפט בוליאני, כלומר true או false.

תחביר

 object.hasOwnProperty(propname) 

טַעֲנָה

הקלטה:

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

 var movie = { name: 'iron man', genre: 'super hit', } var song = { name: 'cardigan', } movie.hasOwnProperty('name'); // returns true movie.hasOwnProperty('type'); // returns false song.hasOwnProperty('name'); // returns true song.hasOwnProperty('status'); // returns false 

היבט חשוב אחד שכדאי לציין כאן הוא שהשיטה hasOwnProperty() מתעלמת בדרך כלל ממאפיינים שעברו בירושה. משמעות הדבר היא שהשיטה תחזיר את ה-true שלה אם האובייקט נמצא כבעל מאפיין שאינו עובר בירושה והשם יצוין על ידי propname. אם הוא מחזיר false, אז זה אומר שלאובייקט אין שום מאפיין עם שם מוגדר, או שהוא ירש את המאפיין מהאובייקט של ה-proptype.

 // Create an object var o = new Object(); // Define a noninherited local property o.x = 3.14; o.hasOwnProperty('x'); // Returns true: x is a local property of o o.hasOwnProperty('y'); // Returns false: o doesn't have a property y o.hasOwnProperty('toString'); // Returns false: toString property is inherited hasOwnProperty() will return true even if you define the undefined or null value. let a = new Object(); a.propertyOne = null; a.hasOwnProperty('propertyOne') // output: true a.propertyTwo = undefined; a.hasOwnProperty('propertyTwo') //Output: true 

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

 function Car(name) { this.name = name; } Car.prototype.color = 'red'; const bmw = new Car('x1'); console.log(bmw.name); // property found on object console.log(bmw.color); // color property found on prototype console.log(bmw.hasOwnProperty('name')); // name is found on the object itself console.log(bmw.hasOwnProperty('color')); // color property is not found on the object itself 

בקטע הקוד שניתן לעיל, המשתנה יוצר אובייקט חדש, אוטו . כעת ניתן לקבוע כי המכונית יזומה כאשר המאפיינים והשם שלה מוגדרים תחת הקונסטרוקטור. למרות שייתכן שהצבע לא יוזכר בתוך האובייקט בעת ההפעלה, הוא תמיד יהיה זמין בדגם האב-טיפוס הִיֵרַרכִיָה . לכן, ה-hasOwnProperty() יחזיר true תמיד עבור השם, אבל עבור color, הוא יחזיר false.

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

 // declaring a Car function function Car(name) { this.name = name; } // setting up new prop with prototype Car.prototype.color = 'red'; // creating a new Car object const BMW = new Car('x1'); // looping through every car prop including prototype as well for (let car in BMW) { car + ':', BMW[car]; } /* output: name: x1 output: color: red */ /**************************************/ /*will loop through only self properties of the object, excludes property generated through prototype method */ for (let car in BMW) { if (BMW.hasOwnProperty(car)) { console.log(car + ':', BMW[car]); } } // output: name: 

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

 var harrypotter = { hasOwnProperty: function() { return true; } }; // Outputs: true console.log(harrypotter.hasOwnProperty('ridikulus')); 

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

 // Returns false Object.prototype.hasOwnProperty.call(harrypotter, 'ridikulus'); 

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

 // Returns false Obje ct.prototype.hasOwnProperty.call(harrypotter, 'ridikulus'); 

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

 var fantasyLit = { tolkien: 'The Lord of the Rings', lewis: 'The Chronicles of Narnia' }; // Outputs: true console.log('tolkien' in fantasyLit); // Outputs: false console.log('asimov' in fantasyLit); // Outputs: true console.log('constructor' in fantasyLit); 

בקטע הקוד שלמעלה, ברור ששיטת 'in' עוקבת אחר מאפיין הבנאי של Object.prototype שממנו עוברים כל האובייקטים בירושה.

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

שקול את קטע הקוד הבא שמראה כיצד שתי השיטות עושות את הדרך לעקיפת הבעיה.

 // Puts a 'declared' property on the global object // (window in browsers) var declared; // Outputs: true console.log('declared' in window); // Outputs: true console.log(window.hasOwnProperty('declared')); // Outputs: undefined console.log(declared); var obj = { myUndefined: undefined }; // Outputs: true console.log('myUndefined' in obj); // Outputs: true console.log(obj.hasOwnProperty('myUndefined')); // Outputs: undefined console.log(obj.myUndefined); 

סיכום

במדריך זה, דנו בשיטת hasOwnProperty() ב-JavaScript. באופן כללי, שיטה זו היא בחירה מצוינת עבור רוב המפתחים לברר ולהימנע מבעיות הקשורות לכמה מפתחות מיוחדים כמו בנאי. מומלץ שאם נמצא אובייקט כלשהו בעל מאפיין כלשהו, ​​הוא ישתמש ב-hasOwnProperty() כברירת מחדל. במקרה של נוכחות של פונקציה שנועדה לבצע קריאה על ידי בדיקת האובייקט עבור שיטת toString(), עלינו להשתמש ב- in.