ירושה ב javascript

אובייקט זה אוסף של key ו value אובייקטים ב js הם דינאמים ז"א שאפשר להוסיף להם key או למחוק להם key במהלך ריצה

הוספה:

obj.someKey=someValue

מחיקה:

delete. obj.someKey

כאשר פונים לאובייקט שה key  שלא לא קיים מקבלים undifined, ככה אפשר לבדוק אם key מסויים קיים באובייקט.

פונקציה היא אובייקט ולכל פונקציה יש key נוסף שנקרא גם prototype

לכל אובייקט יש key שנקרא __proto__ הערך שה key הזה מכיר הוא ממי האובייקטהזה יורש כל אובייקט יורש מאובייקט אחר עד שמגיעים לאובייקט האחרון שהוא יורש מ null

האובייקט האחרון שכל (כמעט כל) האובייקטים יורשים ממנו בסופו של דבר נקרא Object.prototype שהוא מכיל פונקציות שאפשר להשתמש בהם על האובייקט החדש שניצור למשל valueOf או toString אפשר לקרא פה קצת עליו

וה – __proto__ שלו הוא null אפשר להריץ

alert(Object.prototype.__proto__)

 

שיטה ליצור אובייקט נראית ככה

var obj = {
    key1: 'value1',
    key2: 'value2'
}

האובייקט הזה נקרא אובייקט ליטרלי ואני לא יכול לקבוע מי יהיה האבא שלו.

בזיכרון זה נראה ככה:

obj {
  __proto__:Object.prototype,
  key1: value1,
  key2: value2
}

התווסף לנו __proto__:Object.prototype שזה בעצם אומר ממי האובייקט הזה יורש, Object.prototype הוא אובייקט שנקרא Object שיש לו key שנקרא prototype , ואנחנו לא קובעים מי יהיה האבא.

ישנם דרכים נוספות ליצור אובייקט שבהם אפשר להגדיר מי יהיה האבא דרך 1 דרך הפקודה

Object.create(proto[, propertiesObject])

דוגמא לירושה מאובייקט שנקרא someObject

o = Object.create(someObject, {
  foo: { writable: true, configurable: true, value: 'hello' },
  bar: {
    configurable: false,
    get: function() { return 10; },
    set: function(value) { console.log('Setting `o.bar` to', value); }
  }
});

ניתן ליצור אובייקט גם ע"י constructor

דוגמא ליצירת אובייקט ע"י  constructor ( פונקציה )

function Car (color,model) {
  this.color=color;
  this.model=model;
}

var subaru = new Car('red',23456)

כאשר אני יוצר אובייקט ע"י constructor הוא ירש מ constructor.prototype , כלומר ה prototype של הפונקציה, כמו שאמרנו בהתחלה פונקציה היא גם אובייקט ולאובייקט של הפונקציה יש key נוסף אוטומטי שנקרא prototype , שאותו האובייקט שלנו subaru ירש כלומר ה __proto__ של subaru יצביע על Car.prototype.

אם למשל אני אשנה את ה prototype של Car ואוסיף לו פונקציה אזי הפונקציה תהיה זמינה גם ל subaru כלומר subaru ירש אותה וגם כל אובייקט שנייצר ע"י Car

דוגמא להוספת מטודה שנקראת drive

Car.prototype.drive = function () { ..... }

דוגמא ליצירת קלאסס בשם Car ולהוסיף לו כמה מתודות.

function Car (desc) {
    this.desc = desc;
    this.color = "red";
}
 
Car.prototype = {
    getInfo: function() {
      return 'A ' + this.color + ' ' + this.desc + '.';
    },
    drive: function() {
      //DO SOMETHING
    },
    stop: function() {
      //DO SOMETHING
    }
};

עוד דוגמא לצורת רישום

function Car (desc) {
    this.desc = desc;
    this.color = "red";
}
 
Car.prototype = {
    getInfo: function() {
      return 'A ' + this.color + ' ' + this.desc + '.';
    }
};
//instantiate object using the constructor function
var car =  Object.create(Car.prototype);
car.color = "blue";
alert(car.getInfo()); //displays 'A blue undefined.' ??!

 

דוגמא שמראה יצירת אובייקט עם אבא ב 2 הדרכים.

function Constructor() {}
o = new Constructor();
// זה כמו לרשום 
o = Object.create(Constructor.prototype);

 

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

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