Рубрики
Без рубрики

Полиморфизм

ВВЕДЕНИЕ Полиморфизм – это термин, используемый с экземплярами функции конструктора, чтобы дать … Tagged с начинающими, JavaScript.

Введение

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

В первую очередь он используется для сокращения кода в объектно-ориентированном программировании, чтобы убедиться, что опыт работы обтекается, давая «писать меньше, делать больше», если хотите.

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

Как это работает?

Когда мы создаем экземпляр функции конструктора, у нас в основном есть два варианта в синтаксисе в JavaScript 1 : Es5 и Es6 Анкет Es5 более знаком большинству кодеров, так как он не отнимает ни одного из синтаксиса, который был с момента создания JavaScript. Es6 функционально идентичен, но он добавляет много синтаксического сахара, чтобы сделать его намного удобнее смотреть.

Для примеров мы будем использовать Es5 синтаксис.

Для Es5 , когда мы хотим назвать то, что называется Superclass , или его класс «родитель», мы делаем это с удобным названным .call (это) . это призывается к контексту, так как мы хотим, чтобы сам конструктор был создан с родительским классом. Также не забудьте пройти в каких -либо соответствующих аргументах, которые ваш подкласс нуждается в дефолте Superclass!

Также имейте в виду, что, поскольку мы называем суперкласс на самом подклассе, это означает Прототип также скопирован. Обязательно скопируйте это с Object.Create ( .prototype) к правильному имени конструктора, прежде чем двигаться дальше. То же самое касается Prototype.constructor конкретно. Помните, вы скопированный Прото Так вы должны убедиться, что все имена имеют отношение к их контексту.

// Superclass declaration
const Auto = function(owner) {
  this.owner = owner;
};
Auto.prototype.drive = function() {
  /* {...} */
};

// Subclass declaration
const Car = function(make, model, owner) {
  // Calling the superclass, Auto, with .call(this), also passing in the owner param.
  Auto.call(this, owner);
  this.make = make;
  this.model = model;
};
// Copying the proto...
Car.prototype = Object.create(Auto.prototype);
// Changing the constructor function. This is important for when the call stack needs 
// to refer back to something. As with everything, you should ALWAYS keep information 
// relevant.
Car.prototype.constructor = Car;

Es6 Однако не нужно делать все это Object.Create () вещь после базовой функции. На самом деле, потому что Es6 Имеет совершенно другой синтаксис, вы делаете вещи так же по -другому. Когда вы определяете свой Constructor () {} , вы начинаете с звонка Superclass с метко названным Super () Функция еще раз пропустив соответствующие параметры.

Кроме того, вместо того, чтобы делать .call (this, ... args) , чтобы определить Что Суперкласс, вы используете еще одно ключевое слово это Es6 добавлено, это расширяется . Вы размещаете его после имени своего класса, но перед блоком кода.

// Superclass
class Auto {
  constructor(owner) {
    this.owner = owner;
  }
  drive() {
    /* {...} */
  }
}

// Subclass
// Notice how we add "extends Auto" after the normal naming.
class Car extends Auto {
  constructor(make, model, owner) {
    // super(owner) is basically .call(this, owner). In this case,
    //  is Auto.
    super(owner);
  }
  // And we don't need anything else. "extends" does that jumble of mess below the
  // base for us.
}

И если вы чувствуете себя очень смелым, знайте, что подклассы также могут иметь свои подклассы, те же правила применяются, что и раньше. Это делает «дерево» цепочки вызовов, призывая все больше и больше общих родительских классов, чтобы вернуть все свойства, которые должны принадлежать всем подклассам, или для хардкодов определенных параметров, в зависимости от того, что вы пытаетесь сделать.

class Car extends Auto {
  constructor(make, model, owner) {
    super(owner);
    this.make = make;
    this.model = model;
  }
}

class FordCar extends Car {
  // Notice how the parameters for the constructor get shorter the more hardcoded things
  // you enter.
  constructor(model, owner) {
    super('Ford', model, owner);
    this.model = model;
  }
}

class FordFocus extends FordCar {
  constructor(owner) {
    super('Focus', owner);
  }
}
// This could go on for a while, but you get the idea.

/*
  And in case you need a bit more of a visual...
  FordFocus('James') is calling
  FordCar('Focus', 'James') which is calling
  Car('Ford', 'Focus', 'James').
*/

Вывод

Полиморфизм это довольно простая концепция, главным образом, в объектно-ориентированном программировании, используемом для создания «дерева» конструкторов, для сокращения кода, необходимого для написания, что кажется чередом в таких небольших примерах, но может быть спасением в гораздо больших проектах. И понимание этой концепции тщательно позволяет вам сделать ваш код чище, короче и с гораздо меньше хлопот, чем если бы вы сделали это отдельно.

СПИСОК СПАСИБО
  1. JavaScript не является главным образом объектно-ориентированным языком программирования, и аналогично термин Полиморфизм не зарезервирован для этого. Это концепция, которая находится на таких языках, как Python, C/#/++ и Java, которые больше внимания уделяют ООП, учитывая их структуру.

Оригинал: “https://dev.to/corcalla7/polymorphism-i51”

Читайте ещё по теме: