Четыре столпа объектно-ориентированного программирования

Автор оригинала: FreeCodeCamp Community Member.

JavaScript – это мультипарадигма языка и может быть написана после разных парадигм программирования. Парадигма программирования по сути является куча правил, которые вы следуете при записи кода, чтобы помочь вам решить конкретную проблему.

Это то, что четыре стойки. Там принципы проектирования программного обеспечения, которые помогут вам написать чистый объектно-ориентированный код.

Четыре колонны объектно-ориентированного программирования:

Абстракция
Инкапсуляция
Наследование
Полиморфизм

Давайте приблизимся к каждому из них.

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

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

Вы можете создать многоразовый, простой для понимания и легко изменяемой кодовой базы, абстрагируя определенные детали. Позвольте мне привести Вам пример:

function hitAPI(type){
	if (type instanceof InitialLoad) {
		// Implementation example
	} else if (type instanceof NavBar) {
		// Implementation example
	} else {
		// Implementation example
	}
}

Можете ли вы увидеть в примере, как вы должны реализовать именно то, что вам нужно для вашего пользовательского использования?

Каждый новый API, который вам нужен, нужен новый Если Блок, и это собственный пользовательский код. Это не отстраивается, как вам нужно беспокоиться о реализации для каждого добавления каждого нового типа. Это не многоразовый и является техническим кошмаром.

Как насчет чего-то вроде ниже?

hitApi('www.kealanparr.com', HTTPMethod.Get)

Теперь вы можете просто пройти URL-адрес вашей функции и какой метод HTTP вы хотите использовать, и вы закончите.

Вам не нужно беспокоиться о том, как работает функция. Это касалось. Это массивно помогает повторному использованию кода! И делает ваш код намного более удобным.

Вот что Абстракция это все о. Нахождение вещей, которые похожи в вашем коде и обеспечивают общую функцию или объект для обслуживания нескольких мест/с несколькими проблемами.

Вот хороший окончательный пример Абстракция : Представьте, что если вы создали машину, чтобы сделать кофе для ваших пользователей. Там могут быть два подхода:

Как создать его с абстракцией

Есть кнопка с названием «Сделай кофе»

Как создать его без абстракции

Есть кнопка с названием «варить воду»
Есть кнопка с названием «Добавить холодную воду в чайник»
Есть кнопка с заголовком «Добавить 1 ложку заземления кофе на чистую чашку»
Есть кнопка с названием «Очистите любые грязные чашки»
И все другие кнопки

Это очень простой пример, но первый подход Тезисы прочь логика в машину. Но второй подход заставляет пользователя понять, как сделать кофе и по сути сделать свои собственные.

Следующий столб показывает нам один способ достичь Абстракция Используя Инкапсуляция.

Определение инкапсуляции – это «действие ограждения чего-либо в или, как будто в капсуле». Удаление доступа к частям вашего кода и создание вещей в том, что именно то, что Инкапсуляция Все обходится (часто люди, люди относятся к нему как скрывание данных).

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

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

Частные свойства достигаются в JavaScript с помощью закрытия. Вот пример ниже:

var Dog = (function () {

	// Private
	var play = function () {
		// play implementation
	};
    
	// Private
	var breed = "Dalmatian"
    
	// Public
	var name = "Rex";

	// Public
	var makeNoise = function () {
 		return 'Bark bark!';
	};

 	return {
		makeNoise: makeNoise,
		name: name
 	};
})();

Первое, что мы сделали, было создать функцию, которая сразу же называется (называется Meeting немедленно вызывала функцию выражения или iife для коротких). Это создало объект, который может получить доступ, но спрятал некоторые детали. Вы не можете позвонить Играть И вы не можете получить доступ к порода Поскольку мы не разоблачали его в конечный объект с возвратом.

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

Я хочу сосредоточиться на идее Инкапсуляция (Как это важнее, чем просто изучать один шаблон и подсчет Инкапсуляция как полностью завершено сейчас).

Подумайте и думайте больше о том, как вы можете спрятать ваши данные и код и отделить его. Модульные и имеющие четкие обязанности являются ключом к Объектная ориентация Отказ

Почему мы должны предпочитать конфиденциальность? Почему бы не просто все глобальные?

Многие несвязанные биты кода станут зависимыми/связаны друг с другом через глобальную переменную.
Вы, скорее всего, переопределите переменные, если имени получают повторно используемые, которые могут привести к ошибкам или непредсказуемым поведению.
Вы, скорее всего, окажусь с Код спагетти – Код, который трудно просматривать и следовать тому, что есть чтение и запись в ваши переменные и изменение состояния.

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

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

Наследование позволяет одному объекту приобретать свойства и методы другого объекта. В JavaScript это делается по Прототипов наследования Отказ

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

Всякий раз, когда мы используем наследство, мы пытаемся сделать это так, чтобы родитель и ребенок были высокая сплоченность. Сплоченность Как связаны ваш код. Например, делает Птица Тип простирается от Dieselengine тип?

Держите свое наследство просто понять и предсказуемо. Не наследуйте от где-то совершенно не связанного, потому что есть один метод или свойство, необходимое. Наследование не исправляет эту особую проблему хорошо.

При использовании наследования вы должны требовать большую часть функциональности (вам не всегда нужно абсолютно все).

Разработчики имеют принцип, называемый Принцип замены Liskov Отказ Он утверждает, что если вы можете использовать родительский класс (давайте назовем это ParttyPeepe ) Где вы используете ребенка (давайте назовем это ChildType ) – и ChildType наследует от Parttypepe – Тогда вы проходите тест.

Основная причина, по которой вы потерпите неудачу этот тест, если ChildType Снимает вещи от родителя. Если ChildType Удаленные методы, которые он унаследовал от родителя, это приведет к Типеррор где все не определено, что вы ожидаете не быть.

Цепочка наследования – это термин, используемый для описания потока наследования от прототипа базового объекта (тот, который все остальное наследует от) до «конца» цепочки наследования (последний тип, который наследует – собака в выше примера).

Сделайте все возможное, чтобы ваши цепи наследования чистыми и разумными. Вы можете легко в конечном итоге кодировать антиблокировки при использовании Наследование ( называется хрупкая база анти-образца ). Это происходит, где ваши базовые прототипы считаются «хрупкими», потому что вы делаете «безопасное» изменение на базовый объект, а затем начните разбивать всех ваших детей.

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

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

С последней диаграммы у нас может быть базовый прототип, который называется Животное который определяет Макекез Отказ Затем каждый тип, распространяющийся из этого прототипа, может переопределить, чтобы выполнить собственную пользовательскую работу. Что-то вроде этого:

// Let's set up an Animal and Dog example
function Animal(){}
function Dog(){}

Animal.prototype.makeNoise = function(){
	console.log("Base noise");
};

// Most animals we code up have 4. This can be overridden if needed
Animal.prototype.legs = 4;

Dog.prototype = new Animal();

Dog.prototype.makeNoise = function(){
	console.log("Woof woof");  
};

var animal = new Animal();
var dog = new Dog();

animal.makeNoise(); // Base noise
dog.makeNoise();    // Woof woof- this was overridden
dog.legs;           // 4! This was inherited

Собака простирается от Животное и может использовать по умолчанию Ноги имущество. Но он также способен выполнять собственную реализацию вносить собственный шум.

Настоящая сила полиморфизма совмещает поведение и позволяет отказ от переоценки.

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

Я разделяю свое письмо на Twitter Если вы наслаждались этой статьей и хотите увидеть больше.

Как создать его с абстракцией

Как создать его без абстракции

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