концепция прототипного наследования в javascript как языке, основанном на прототипе

вы знаете, что Javascript-это язык программирования на основе прототипов .
Я прочитал несколько книг о Javascript и его прототипного наследования концепция, но:

8
javascript prototypal-inheritance prototype prototype-programming prototypejs

6 ответов

классическое наследование о расширении типов вещей. Скажем у вас есть класс, как Bike. Когда вы хотите расширить поведение, вы должны разработать новый тип велосипеда (например,MotorBike).

прототип на основе наследования о расширяя вещи сами. Скажите, что у вас есть способ сделать Bike объекты. Возьмите один из этих Bikes в вашем гараже, и вы привязываете к нему реактивный двигатель.

это не соответствует плану. Это то, что вы сделали с этим конкретным велосипедом. Но твои друзья видят твое изобретение и тоже хотят его. Поэтому вместо того, чтобы сделать чертеж для вашего нового дизайна, вы вешаете табличку с надписью "JetBike factory " и просто начните делать больше из них. И каждый раз ты не можешь. помните, как что-то сочетается, вместо того, чтобы смотреть на чертеж, вы просто смотрите на свой оригинальный велосипед. Ваш оригинальный велосипед прототип велосипед, и все новые мотоциклы на его основе.

теперь, для подлинного 6-летнего, Это, вероятно, где я бы остановился (если бы я их уже не потерял), но на самом деле прототипное наследование не просто создает копии, оно делает что-то еще круче - оно фактически связывает новое JetBike объекты исходного прототипа велосипед у вас в гараже. Если вы замените подвеску на своем прототипе велосипеда, то велосипеды всех ваших друзей также волшебным образом заменят свою подвеску.

давайте посмотрим на некоторый псевдо-код JS-ish:

function Bike() {
    this.wheels = 2;
}
Bike.prototype = {
    ride: function() {
        // Ride the bike
    },
    crash: function() {
        // Fall off the bike
    }
};

function JetBike() {
    this.engines = 2;
}
// Start with an ordinary bike
JetBike.prototype = new Bike();
// Modify it
JetBike.prototype.fly = function () {
    // Engage thrusters and head for the ramp
};
10

Javascript-объектно-ориентированный язык, уникальный тем, что он не имеет классов. Вместо этого мы используем функции для создания объектов.

все функции имеют прототип, из которого все объекты, созданные с помощью этой функции, наследуют все свойства и методы. Поскольку Javscript не имеет классов, вы выполняете наследование, используя фактический объект для наследования (в отличие от класса). Вы можете установить прототип функции для объекта, позволяя создавать все объекты с этой функцией наследовать все методы и свойства объекта-прототипа функции.

Так что если у меня есть функция, которая создает объект:

function Foo() {

}
Foo.prototype.someProperty = 'blahblahblah';

вы можете создать другую функцию, которая создает объект, и позволить ей наследовать свойства и методы объектов, установив прототип функций для этого объекта.

function Bar() {

}
Bar.prototype = new Foo();

тогда вы можете получить доступ ко всем вещам, которые были унаследованы.

var bar = new Bar();
alert( bar.someProperty ); // blahblahblah
2

в отличие от большинства других объектно-ориентированных языков, JavaScript фактически не имеет концепции классов. В большинстве других объектно-ориентированных языков вы бы создали экземпляр определенного класса, но это не так в JavaScript.
в JavaScript объекты могут создавать новые объекты, а объекты могут наследовать от других объектов.
Вся эта концепция называется прототипного наследования.

но как мы можем сделать объект?
Просто вы можете создать общий объект с помощью {}.

var a = {};
a.prop = "myprop";
console.log(a); //Object { prop="myprop" }

вы не можете создать экземпляр a потому что это не функция. другими словами, он не имеет специального внутреннего метода [[Construct]].

в JavaScript любая функция также может быть создана как объект. Функция ниже-это простая функция, которая принимает имя и сохраняет его в текущем контексте:

function User( name ) {
   this.name = name;
}

мы видим, что User это экземпляр Функция:

alert(User instanceof Function); //true

создайте новый экземпляр этой функции с указанным именем:

var me = new User( "My Name" );

мы видим, что его name было установлено как свойство само по себе:

alert( me.name == "My Name" ); //true

и что это экземпляр

2

интересные задачи :-)

прежде всего, я бы никогда не попытался объяснить это кому-либо, просто используя слова, но я попробую: -)

"прототипное наследование похоже на покемона, который может украсть силы у других покемонов."

думаю, что вы могли бы создать свой собственный покемон. Вы можете решить, насколько он большой,какого цвета и т. д. (конструктор.) Тогда вы можете дать, что pokemon полномочия (прототипы). Вы можете породить столько этих покемонов, сколько захотите. Прототипное наследование дает вам возможность позволить одному, нескольким или всем этим покемонам украсть силы у других покемонов. Вы даже можете украсть полномочия у покемонов, которые уже украли полномочия у другого покемона. Это создает совершенно новый диапазон супермощных покемонов.

может быть, немного глупо, но это отражает, насколько мощное прототипное наследование... в Покемон смысле: -)

1

прототипное наследование - это как сын, несущий своего отца на спине, куда бы он ни пошел. Если кто-то спросит сына: "какого цвета твои туфли?- Он бы ответил цветом своих ботинок, если только он не босиком,тогда он ответил бы цветом своих отцов.

1
/* Here is simple way how to inherit objects properties and methods from others object by using prototyping inheritance in plain java script.*/
(function() {  
      // get dom elements for display output`enter code here
      var engTeacherPara = document.getElementById("engTeacher");
      var chemTeacherPara = document.getElementById("chemTeacher");
      // base class 
      var SchoolStaff = function(name, id) {
          this.name = name;
          this.id = id;
        }
        // method on the SchoolStaff object
      SchoolStaff.prototype.print = function() {
        return "Name : " + this.name + " Employee id: " + this.id;
      }

      SchoolStaff.prototype.sayHello = function() {
        return "Hello Mr : " + this.name;
      }

      // sub class engTeacher
      var EngTeacher = function(name, id, salary) {
          SchoolStaff.call(this, name, id);
          this.salary = salary;
        }
        // Inherit the SchoolStaff prototype
      EngTeacher.prototype = Object.create(SchoolStaff.prototype);

      // Set the engTeacher constructor to engTeacher object
      EngTeacher.prototype.constructor = EngTeacher;

      // method on engTeacher object
      EngTeacher.prototype.print = function() {
        return "Name : " + this.name + " Salary : " + this.salary + " Employee id: " + this.id;
      }

      // sub class chemTeacher
      var ChemTeacher = function(name, id, salary, bonus) {
          EngTeacher.call(this, name, id, salary);
          this.bonus = bonus;
        }
        // Inherit the SchoolStaff prototype
      ChemTeacher.prototype = Object.create(EngTeacher.prototype);

      // Set the engTeacher constructor to engTeacher object
      ChemTeacher.prototype.constructor = ChemTeacher;

      // method on engTeacher object
      ChemTeacher.prototype.print = function() {
        console.log("Name : " + this.name + " Salary : " + this.salary + " Employee id: " + this.id + " bonus : " + this.bonus);
      }

      // create new objcts and check sub class have base class methods access
      var schoolStaff = new SchoolStaff("Base Class", 100);
      console.log(schoolStaff.sayHello()); // Hello Mr : Base Class

      var engTeacher = new EngTeacher("Eng Teacher", 1001, 20000);
      engTeacherPara.innerHTML = engTeacher.sayHello(); // Hello Mr : Eng Teacher  

      var chemTeacher = new ChemTeacher("Chem Teacher", 1001, 30000, 4000);
      chemTeacherPara.innerHTML = chemTeacher.sayHello(); // Hello Mr : Chem Teacher
    })();
0