Прототипное программирование: javascript — Прототипное программирование ?

Прототипное программирование | это… Что такое Прототипное программирование?

Для термина «Прототип» см. другие значения.

Парадигмы программирования

Агентно-ориентированная Компонентно-ориентированная Конкатенативная Декларативная (контрастирует с Императивной) Ограничениями Функциональная Потоком данных Таблично-ориентированная (электронные таблицы) Реактивная Логическая Событийно-ориентированная Сервис-ориентированная Комбинаторная Императивная (контрастирует с Декларативной) Процедурная Предметно-ориентированная Метапрограммирование Автоматизация процесса программирования Обобщённое программирование Рефлексивно-ориентированная Итерационная Параллельная Структурная Модульная Рекурсивная Объектно-ориентированная Автоматная Разделение ответственности: Аспектно-ориентированная Субъектно-ориентированная Прототип-ориентированная  Шаблон: Просмотр • стиль объектно-ориентированного программирования, при котором отсутствует понятие класса, а повторное использование (наследование) производится путём клонирования существующего экземпляра объекта — прототипа. Каноническим примером прототип-ориентированного языка является язык Self. В дальнейшем этот стиль программирования начал обретать популярность и был положен в основу таких языков программирования, как JavaScript, Lua, Io, REBOL и др. Содержание 1 Сравнение с класс-ориентированным подходом 2 Конструирование объектов 2.1 Делегирование 2.2 Каскадирование 3 Критика 4 Языки 5 Примечания 6 Литература 7 Ссылки Сравнение с класс-ориентированным подходом В языках, основанных на понятии «класс», все объекты разделены на два основных типа — классы и экземпляры. Класс определяет структуру и функциональность (поведение), одинаковую для всех экземпляров данного класса. Экземпляр является носителем данных — то есть обладает состоянием, меняющимся в соответствии с поведением, заданным классом. Сторонники прототипного программирования часто утверждают, что языки, основанные на классах, приводят к излишней концентрации на таксономии классов и на отношениях между ними. В противоположность этому, прототипирование заостряет внимание на поведении некоторого (небольшого) количества «образцов», которые затем классифицируются как «базовые» объекты и используются для создания других объектов. Многие прототип-ориентированные системы поддерживают изменение прототипов во время выполнения программы, тогда как лишь небольшая часть класс-ориентированных систем (например, Smalltalk, Ruby) позволяет динамически изменять классы. Хотя подавляющее большинство прототип-ориентированных систем основаны на интерпретируемых языках с динамической типизацией, технически возможно добавить прототипирование и в языки со статической проверкой типов. Язык Omega является одним из примеров такой системы. Конструирование объектов В класс-ориентированных языках новый экземпляр создаётся через вызов конструктора класса (возможно, с набором параметров). Получившийся экземпляр имеет структуру и поведение, жёстко заданные его классом. В прототип-ориентированных системах предоставляется два метода создания нового объекта: клонирование существующего объекта, либо создание объекта «с нуля». Для создания объекта с нуля программисту предоставляются синтаксические средства добавления свойств и методов в объект. В дальнейшем, с получившегося объекта может быть получена полная копия — клон. В процессе клонирования копия наследует все характеристики своего прототипа, но с этого момента она становится самостоятельной и может быть изменена. В некоторых реализациях копии хранят ссылки на объекты-прототипы, делегируя им часть своей функциональности; при этом изменение прототипа может затронуть все его копии. В других реализациях новые объекты полностью независимы от своих прототипов. Ниже рассмотрены оба этих случая. Делегирование Основная статья: Делегирование (программирование) В прототип-ориентированных языках, использующих делегирование, среда исполнения способна выполнять диспетчеризацию вызовов методов (или поиск нужных данных) просто следуя по цепочке делегирующих указателей (от объекта к его прототипу), до совпадения. В отличие от отношения «класс — экземпляр», отношение «прототип — потомки» не требует, чтобы объекты-потомки сохраняли структурное подобие со своим прототипом. С течением времени они могут адаптироваться и улучшаться, но при этом нет нужды переделывать прототип. Важно, что добавлять/удалять/модифицировать можно не только данные, но и функции, при этом функции тоже оказываются объектами первого уровня. Вследствие этого большинство прототип-ориентированных языков называют данные и методы объекта «слотами» (ячейками). Каскадирование При «чистом» прототипировании — именуемом также каскадным и представленом в Kevo — клонированные объекты не хранят ссылок на свои прототипы. Прототип копируется один-в-один, со всеми методами и атрибутами, и копии присваивается новое имя (ссылка). Это напоминает митоз биологических клеток. В число преимуществ данного подхода входит тот факт, что создатель копии может менять её, не опасаясь побочных эффектов среди других потомков своего предка. Также радикально снижаются вычислительные затраты на диспетчеризацию, так как нет необходимости обходить всю цепочку возможных делегатов в поисках подходящего слота (метода или атрибута). В число недостатков можно включить трудности с распространением изменений в системе: модификация прототипа не влечёт за собой немедленное и автоматическое изменение всех его потомков. Тем не менее, Kevo предоставляет дополнительные средства для публикации изменений среди множества объектов, причём на основании их подобия («семейного сходства»), а не по наличию общего предка, что типично для моделей с делегированием. Другой недостаток в том, что простейшие реализации этой модели приводят к увеличенному (по сравнению с моделью делегирования) расходу памяти, так как каждый клон, пока он не изменён, будет содержать копию данных своего прототипа. Однако эта проблема разрешима оптимальным разделением неизменённых данных и применением «ленивого копирования» — что и было использовано в Kevo. Критика Сторонников класс-ориентированных объектных моделей, критикующих прототипный подход, часто беспокоят те же проблемы, какими обеспокоены сторонники статической типизации в отношении к языкам с динамической типизацией. В частности, обсуждения вращаются вокруг таких тем, как правильность, безопасность, предсказуемость и эффективность программы. Что касается первых трёх пунктов, то классы часто рассматриваются как типы (и действительно, в большинстве объектно-ориентированных языков со статической типизацией так оно и есть), и предполагается, что классы предоставляют определённые договорённости и гарантируют, что экземпляры будут вести себя вполне определённым образом. В части эффективности, объявление классов значительно упрощает компилятору задачу оптимизации, делая более эффективными как методы, так и поиск атрибутов в экземплярах. В случае языка Self немалая часть времени была потрачена на разработку таких техник компиляции и интерпретации, которые позволили бы приблизить производительность прототип-ориентированных систем к их класс-ориентированным конкурентам. Дальнейшая работа в этом направлении, а также прогресс в теории JIT-компиляторов привели к тому, что в настоящее время различие между класс- и прототип-ориентированными подходами мало влияет на эффективность результирующего кода. В частности, прототип-ориентированная Lua является одним из самых быстрых интерпретируемых языков и напрямую соперничает со многими компилируемыми,[1] а транслятор языка Lisaac генерирует код ANSI C, практически не уступающий нативному. [2] Наконец, возможно наиболее общим местом критики против прототипного программирования является то, что сообщество разработчиков програмного обеспечения недостаточно хорошо знакомо с ним, несмотря на популярность и распространённость JavaScript. Вдобавок, так как прототип-ориентированные системы сравнительно новы и всё ещё немногочисленны и редки, приёмы разработки с их использованием до сих пор не получили большого распространения. Языки Actor-Based Concurrent Language, ABCL: ABCL/1, ABCL/R, ABCL/R2, ABCL/c+ Agora Cecil Cel ECMAScript, ActionScript (1 и 2 версии), DMDScript, JavaScript, JScript Factor Io Kevo Lua MOO NewtonScript Obliq OpenLaszlo REBOL Self Slate TADS Примечания ↑ Which programming languages are fastest? Computer Language Benchmarks Game. ↑ Lisaac vs. GNU C++ Литература Иан Грэхем Объектно-ориентированные методы. Принципы и практика = Object-Oriented Methods: Principles & Practice. — 3-е изд. — М.: «Вильямс», 2004. — С. 880. — ISBN 0-201-61913-X Ссылки Пименова Михаила Программирование на основе прототипов (prototype): понятие, смысл.  (рус.). Архивировано из первоисточника 19 мая 2012. Проверено 27 октября 2010. Главы 5, 6 и 7 / Flash MX для профессиональных программистов  (рус.). Архивировано из первоисточника 19 мая 2012. Проверено 27 октября 2010. Wikimedia Foundation. 2010. Игры ⚽ Поможем написать курсовую Бельские (Гедиминовичи) Корш Полезное

Программирование основанное на прототипах | это.

.. Что такое Программирование основанное на прототипах?

Хотя подавляющее большинство прототип-ориентированных систем основаны на интерпретируемых языках с динамической типизацией, технически возможно добавить прототипирование и в языки со статической проверкой типов. Язык Omega является одним из примеров такой системы.

Конструирование объектов

В класс-ориентированных языках новый экземпляр создаётся через вызов конструктора класса (возможно, с набором параметров). Получившийся экземпляр имеет структуру и поведение, жёстко заданные его классом.

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

Делегирование

Основная статья: Шаблон делегирования

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

Каскадирование

При «чистом» прототипировании — именуемом также каскадным и представленом в Kevo — клонированные объекты не хранят ссылок на свои прототипы. Прототип копируется один-в-один, со всеми методами и атрибутами, и копии присваивается новое имя (ссылка). Это напоминает митоз биологических клеток.

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

В число недостатков можно включить трудности с распространением изменений в системе: модификация прототипа не влечёт за собой немедленное и автоматическое изменение всех его потомков. Тем не менее, Kevo предоставляет дополнительные средства для публикации изменений среди множества объектов, причём на основании их подобия («семейного сходства»), а не по наличию общего предка, что типично для моделей с делегированием.

Другой недостаток в том, что простейшие реализации этой модели приводят к увеличенному (по сравнению с моделью делегирования) расходу памяти, так как каждый клон, пока он не изменён, будет содержать копию данных своего прототипа. Однако эта проблема разрешима оптимальным разделением неизменённых данных и применением «ленивого копирования» — что и было использовано в Kevo.

Критика

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

Что касается первых трёх пунктов, то классы часто рассматриваются как типы (и действительно, в большинстве объектно-ориентированных языков со статической типизацией так оно и есть), и предполагается, что классы предоставляют определённые договорённости и гарантируют, что экземпляры будут вести себя вполне определённым образом.

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

Наконец, возможно наиболее общим местом критики против прототипного программирования является то, что сообщество разработчиков ПО недостаточно хорошо знакомо с ним, несмотря на популярность и распространённость

Языки

• Actor-Based Concurrent Language, ABCL: ABCL/1, ABCL/R, ABCL/R2, ABCL/c+
• Agora
• Cecil
• Cel
• ActionScript, DMDScript, JScript
• Factor
• Lua
• MOO
• NewtonScript
• Obliq
• REBOL
• TADS

Литература

• Иан Грэхем Объектно-ориентированные методы. Принципы и практика = Object-Oriented Methods: Principles & Practice. — 3-е изд. — М.: «Вильямс», 2004. — С. 880. — ISBN 0-201-61913-X

Концепция прототипно-ориентированного программирования (POP) в Javascript | by Izuking Ogbodo

Чтение: 7 мин.

·

11 мая 2019 г.

Привет всем, сегодня мы увидим, как парадигма объектно-ориентированного программирования реализуется в Javascript.

Но прежде чем мы рассмотрим это, давайте немного углубимся в концепцию самой парадигмы объектно-ориентированного программирования, поскольку она связана с другими языками, такими как Java, Python, Ruby C++, PHP, Javascript и т. д.

Объектно-ориентированное программирование (ООП)

Объектно-ориентированное программирование — это стиль программирования, связанный с концепциями класса, объектов и различными другими концепциями, такими как Наследование , Абстракция , Инкапсуляция и Полиморфизм .

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

Концепции ООП

Как указывалось ранее в приведенном выше объяснении ООП, объектно-ориентированное программирование основано на следующих концепциях:

• Наследование: Отношения и подклассы между объектами могут быть установлены, что позволяет разработчикам повторно использовать общую логику, сохраняя при этом уникальная иерархия. Это свойство ООП требует более тщательного анализа данных, сокращает время разработки и обеспечивает более высокий уровень точности разрабатываемой программы.
• Абстракция: Объекты раскрывают только внутренние механизмы, которые имеют отношение к использованию других объектов, скрывая любой ненужный код реализации. Эта концепция помогает разработчикам легко вносить изменения и дополнения с течением времени.
• Инкапсуляция: Реализация и состояние каждого объекта хранятся внутри определенной границы или класса. Другие объекты не имеют доступа к этому классу или права вносить изменения, но могут вызывать только список общедоступных функций или методов. Эта характеристика сокрытие данных обеспечивает большую безопасность программы и предотвращает непреднамеренное повреждение данных в вашей программе.
• Полиморфизм: Объекты могут принимать более одной формы в зависимости от контекста. Программа определит, какое значение или использование необходимо для каждого выполнения этого объекта, сокращая избыточность кода в программе.

Вот как глубоко мы можем погрузиться в ООП. Теперь давайте продолжим тему объектно-ориентированного программирования на Javascript.

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

Javascript использует прототипно-ориентированный шаблон программирования (POP) для реализации концепции ООП.

Прототип-ориентированное программирование

Прототип-ориентированное программирование (POP) — это стиль объектно-ориентированного программирования (OOP), в котором классы не определяются явно, а вместо этого получаются путем добавления свойств и методов к экземпляру другого класса или, реже , добавляя их к пустому объекту.

Короче говоря, этот стиль программирования основан на клонировании и повторном использовании уже созданного объекта для создания другого объекта в программе или приложениях.

Проще говоря, этот тип концепции программирования позволяет создавать объект без предварительного определения его класса.

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

Программирование на основе прототипов также известно как программирование на основе прототипов, программирование на основе прототипов, бесклассовое программирование или программирование на основе экземпляров.

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

В JavaScript при использовании функции/метода «прототипа»; объект может быть вызван/использован в другой программе без определения его класса (ключевое слово class введено в ES2015, но является синтаксическим сахаром, JavaScript остается основанным на прототипах). JavaScript создает связь между новым объектом и основным объектом. Клонированный/скопированный/прототипированный объект работает так же, как и первичный объект.

JavaScript, Action Script и Newton Script — это языки программирования, основанные на прототипах.

Чтобы еще больше укрепить эту концепцию объектного программирования прототипов, мы рассмотрим проект под названием Lecture Manager .

Полный исходный код проекта можно найти на GitHub.

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

Достаточно забавно, что Javascript реализует эти концепции совершенно иначе, чем обычное соглашение Java и т. д., но все же достигает сути концепций.

Когда дело доходит до наследования , в JavaScript есть только одна конструкция: объекты. Каждый объект имеет частное свойство, которое содержит ссылку на другой объект, называемый его прототипом. Этот объект-прототип имеет собственный прототип, и так далее, пока не будет достигнут объект с нулевым прототипом. По определению null не имеет прототипа и действует как конечная ссылка в этом прототип цепи .

Почти все объекты в JavaScript являются экземплярами Object, которые находятся на вершине цепочки прототипов.

Важно отметить, что сама прототипная модель наследования в Javascript на самом деле более мощная, чем классическая модель. Например, довольно просто построить классическую модель поверх модели-прототипа.

Наследование с цепочкой прототипов

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

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

Постановка задачи

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

Глядя на постановку задачи, мы видим, что это большой проект в реальной жизни. Но из-за того, что мы просто хотим использовать его для закрепления наших знаний о прототипно-ориентированном программировании в Javascript, мы не собираемся углубляться в решение. Помните, что вы можете получить полный исходный код этого проекта на GitHub. Я старался изо всех сил объяснить код здесь.

Прежде всего, давайте создадим наш суперобъект с именем User.js

В приведенном выше коде, от строки 17 до строки 47, вы увидите, как функциональные возможности, которые вы собираетесь наследовать другим объектом, размещаются внутри Прототип объекта пользователя .

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

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

Производительность

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

Но, используя метод цепочки прототипов (т.е. первый подход), независимо от того, сколько объектов мы создадим из объекта User , у нас будет по одной копии каждого метода, находящегося в User. prototype.

По статистике, если объекту требуется доступ к 10 методам, а мы создаем 100 объектов, движок JavaScript создал 1000 новых функций.

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

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

Теперь пусть два дочерних объекта Лектор и Администратор наследуют свойства экземпляра и методы объекта Пользователь .

Позвольте мне быстро объяснить, как используется Object.create() в этой статье.

Object.create() был введен в ECMAScript 5. Вызов этого метода создает новый объект. Прототип 9.0123 Пользовательский объект является первым аргументом функции и возвращает совершенно новый объект, чье свойство __proto__ равно переданному объекту.

Если вы посмотрите на выделенную часть закомментированного кода, вы заметите, как объекты Lecturer и Admin наследуют как свойства экземпляра, так и методы (которые определены в прототипе) объекта User . Таким образом достигается повторное использование кода; в этом смысл концепции наследования в шаблоне объектно-ориентированного программирования, но реализованного с использованием прототипного подхода в Javascript.

Это основной принцип прототипно-ориентированного программирования (POP) в Javascript.

В заключение, наследование в JavaScript реализуется через цепочку прототипов. Каждый обычно созданный объект, массив и функция имеет цепочку прототипов из __proto__ свойств, заканчивающихся Object.prototype вверху. Вот почему все они считаются первоклассными объектами в JavaScript.

Функции имеют свойство прототипа в дополнение к __proto__ свойство. При использовании функции-конструктора с new рекомендуется размещать методы в прототипе функции, а не в самом объекте, как уже объяснялось выше. Возвращенный объект __proto__ будет равен прототипу функции, поэтому он унаследует все методы прототипа функции. Это предотвращает ненужное использование памяти и повышает скорость выполнения программы.

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

• https://www.quora.com/What-are-encapsulation-inheritance-polymorphism-and-abstraction
• https://developer.mozilla.org/en-US/docs/Learn/JavaScript/ Объекты/объектно-ориентированный_JS
• http://voidcanvas. com/es6-private-variables/
• https://medium.com/@rajaraodv/is-class-in-es6-the-new-bad-part- 6c4e6fe1ee65
• https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/Inheritance
  * https://en.wikipedia.org/wiki/Объектно-ориентированное_программирование
• https://en.wikipedia.org/wiki/Объектно-ориентированное_программирование
• https://medium.freecodecamp.org/a-guide-to-prototype-based-class-inheritance-in-javascript-84953db26df0

Прототип против классового объектно-ориентированного программирования | Приябрата Чаттарадж

Является ли JavaScript объектно-ориентированным языком? Самая боевая война, но все еще запутанная.

Priyabrata Chattaraj

·

Читать

Опубликовано в

·

12 мин чтения

·

26 февраля 2022 г.

Это все еще не объяснено должным образом в большей части контента, доступного в Интернете, что затрудняет его, особенно для разработчиков, которые пришли из объектно-ориентированного программирования (ООП).

А еще ООП — это не документированная парадигма программирования, а здравый смысл, который подливает масла в огонь. И если вам зададут этот вопрос в интервью, что бы вы ни говорили, вы должны быть готовы к следующим последствиям, поэтому вы должны защищаться ответами.

Учитывая спрос на ООП в компаниях и объектно-ориентированную структуру JavaScript, будет огромной удачей узнать реализацию ООП в JavaScript. Но прежде чем начать, я предполагаю, что у вас есть базовые знания JavaScript и вы понимаете, почему

«Все в JavaScript является объектом».

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

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

• Ассоциация , ассоциирует (в программном смысле для обозначения) с другими независимыми объектами.
• Агрегация , встраивающая в себя другие независимые объекты.
• Композиция , реализующая внутри себя зависимые объекты.

Способность объекта JavaScript к ассоциации, агрегации и демонстрации композицииВывод вышеуказанного кода

Здесь вы можете подумать, что organiztion.employee[0] указывает на person и person.employeeA указывает на organiztion , это рекурсия и без определенного конца, поэтому машина может зависнуть. Нет это не так. Они сохранили только адрес памяти друг друга.

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

Итак, объект JavaScript имеет данные и поведение (методы) или, в общем, свойства, которые могут ссылаться на другой независимый объект, могут встраивать другой независимый объект или встраивать зависимый объект. При выполнении первого условия объект JavaScript может имитировать объект реального мира.

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

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

Немного информации заранее

ООП на основе классов — это один из стилей ООП. Где поведение объекта определяется до его создания. Класс — это кодовый блок, в котором хранится чертеж или шаблон объектов, который нельзя изменить позже.

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

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

Здесь наследование прикрепляется к живому рабочему объекту, который называется прототип или [[прототип]] или __proto__ и доступен для всех дочерних элементов. Объекты не получают копии унаследованного поведения, они получают объект-прототип и могут быть изменены позже. Он не образует жесткой и жесткой таксономии. Это так же эффективно, как наследование на основе классов.

Класс — это зарезервированное ключевое слово в JavaScript, это просто функция в фоновом режиме, действует как функция-конструктор.

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