Прототипное программирование | это… Что такое Прототипное программирование?
Для термина «Прототип» см. другие значения.
| Парадигмы программирования | |
|---|---|
Шаблон: Просмотр • стиль объектно-ориентированного программирования, при котором отсутствует понятие класса, а повторное использование (наследование) производится путём клонирования существующего экземпляра объекта — прототипа. Каноническим примером прототип-ориентированного языка является язык Self. В дальнейшем этот стиль программирования начал обретать популярность и был положен в основу таких языков программирования, как JavaScript, Lua, Io, REBOL и др.
Сравнение с класс-ориентированным подходомВ языках, основанных на понятии «класс», все объекты разделены на два основных типа — классы и экземпляры. Класс определяет структуру и функциональность (поведение), одинаковую для всех экземпляров данного класса. Экземпляр является носителем данных — то есть обладает состоянием, меняющимся в соответствии с поведением, заданным классом. Сторонники прототипного программирования часто утверждают, что языки, основанные на классах, приводят к излишней концентрации на таксономии классов и на отношениях между ними. В противоположность этому, прототипирование заостряет внимание на поведении некоторого (небольшого) количества «образцов», которые затем классифицируются как «базовые» объекты и используются для создания других объектов. Многие прототип-ориентированные системы поддерживают изменение прототипов во время выполнения программы, тогда как лишь небольшая часть класс-ориентированных систем (например, Smalltalk, Ruby) позволяет динамически изменять классы. Хотя подавляющее большинство прототип-ориентированных систем основаны на интерпретируемых языках с динамической типизацией, технически возможно добавить прототипирование и в языки со статической проверкой типов. Язык Omega является одним из примеров такой системы. Конструирование объектовВ класс-ориентированных языках новый экземпляр создаётся через вызов конструктора класса (возможно, с набором параметров). В прототип-ориентированных системах предоставляется два метода создания нового объекта: клонирование ДелегированиеОсновная статья: Делегирование (программирование) В прототип-ориентированных языках, использующих делегирование, среда исполнения способна выполнять диспетчеризацию вызовов методов (или поиск нужных данных) просто следуя по цепочке делегирующих указателей (от объекта к его прототипу), до совпадения. КаскадированиеПри «чистом» прототипировании — именуемом также каскадным и представленом в Kevo — клонированные объекты не хранят ссылок на свои прототипы. Прототип копируется один-в-один, со всеми методами и атрибутами, и копии присваивается новое имя (ссылка). Это напоминает митоз биологических клеток. В число преимуществ данного подхода входит тот факт, что создатель копии может менять её, не опасаясь побочных эффектов среди других потомков своего предка. В число недостатков можно включить трудности с распространением изменений в системе: модификация прототипа не влечёт за собой немедленное и автоматическое изменение всех его потомков. Тем не менее, Kevo предоставляет дополнительные средства для публикации изменений среди множества объектов, причём на основании их подобия («семейного сходства»), а не по наличию общего предка, что типично для моделей с делегированием. Другой недостаток в том, что простейшие реализации этой модели приводят к увеличенному (по сравнению с моделью делегирования) расходу памяти, так как каждый клон, пока он не изменён, будет содержать копию данных своего прототипа. Однако эта проблема разрешима оптимальным разделением неизменённых данных и применением «ленивого копирования» — что и было использовано в Kevo. КритикаСторонников класс-ориентированных объектных моделей, критикующих прототипный подход, часто беспокоят те же проблемы, какими обеспокоены сторонники статической типизации в отношении к языкам с динамической типизацией. Что касается первых трёх пунктов, то классы часто рассматриваются как типы (и действительно, в большинстве объектно-ориентированных языков со статической типизацией так оно и есть), и предполагается, что классы предоставляют определённые договорённости и гарантируют, что экземпляры будут вести себя вполне определённым образом. В части эффективности, объявление классов значительно упрощает компилятору задачу оптимизации, делая более эффективными как методы, так и поиск атрибутов в экземплярах. В случае языка Self немалая часть времени была потрачена на разработку таких техник компиляции и интерпретации, которые позволили бы приблизить производительность прототип-ориентированных систем к их класс-ориентированным конкурентам. Дальнейшая работа в этом направлении, а также прогресс в теории JIT-компиляторов привели к тому, что в настоящее время различие между класс- и прототип-ориентированными подходами мало влияет на эффективность результирующего кода. Наконец, возможно наиболее общим местом критики против прототипного программирования является то, что сообщество разработчиков програмного обеспечения недостаточно хорошо знакомо с ним, несмотря на популярность и распространённость JavaScript. Вдобавок, так как прототип-ориентированные системы сравнительно новы и всё ещё немногочисленны и редки, приёмы разработки с их использованием до сих пор не получили большого распространения. Языки
Примечания
Литература
Ссылки
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
com/es6-private-variables/Прототип против классового объектно-ориентированного программирования | Приябрата Чаттарадж
Является ли JavaScript объектно-ориентированным языком? Самая боевая война, но все еще запутанная.
Priyabrata Chattaraj
·
Читать
Опубликовано в
·
12 мин чтения
·
26 февраля 2022 г.
Это все еще не объяснено должным образом в большей части контента, доступного в Интернете, что затрудняет его, особенно для разработчиков, которые пришли из объектно-ориентированного программирования (ООП).
А еще ООП — это не документированная парадигма программирования, а здравый смысл, который подливает масла в огонь. И если вам зададут этот вопрос в интервью, что бы вы ни говорили, вы должны быть готовы к следующим последствиям, поэтому вы должны защищаться ответами.
Учитывая спрос на ООП в компаниях и объектно-ориентированную структуру JavaScript, будет огромной удачей узнать реализацию ООП в JavaScript. Но прежде чем начать, я предполагаю, что у вас есть базовые знания JavaScript и вы понимаете, почему
«Все в JavaScript является объектом».
ООП — это парадигма программирования, позволяющая разработчику моделировать реальные проблемы с помощью объектов.
Теперь, чтобы один концептуальный объект представлял один объект или сущность реального мира, он также должен быть связан с другими сущностями.
- Ассоциация , ассоциирует (в программном смысле для обозначения) с другими независимыми объектами.
- Агрегация , встраивающая в себя другие независимые объекты.
- Композиция , реализующая внутри себя зависимые объекты.
Здесь вы можете подумать, что organiztion.employee[0] указывает на person и person.employeeA указывает на organiztion , это рекурсия и без определенного конца, поэтому машина может зависнуть. Нет это не так. Они сохранили только адрес памяти друг друга.
Потому что для непримитивного типа данных переменная не хранит значение, а хранит ссылку памяти на этот объект. Хотя это не лучшая практика, мы можем использовать прокси 9.0124 объектов для моделирования подобных ситуаций для больших задач.
Итак, объект JavaScript имеет данные и поведение (методы) или, в общем, свойства, которые могут ссылаться на другой независимый объект, могут встраивать другой независимый объект или встраивать зависимый объект.
При выполнении первого условия объект JavaScript может имитировать объект реального мира.
ООП подчиняется четырем основным принципам, которые добавляют модульности и повышают возможность повторного использования кода. Это
- Инкапсуляция , говорит о переносе всех свойств в один объект. Это делает код чистым, убирает зависимости, добавляет модульности.
- Абстракция говорит скрыть реализацию, которая является критической или не требует раскрытия. Во избежание ошибок.
- Inheritance говорит о расширении тех же поведений, что делает код многоразовым.
- Полиморфизм , который говорит, что поведение объекта может меняться в зависимости от состояния или контекста, делает код повторно используемым, а также модульным.
Немного информации заранее
ООП на основе классов — это один из стилей ООП.
Где поведение объекта определяется до его создания. Класс — это кодовый блок, в котором хранится чертеж или шаблон объектов, который нельзя изменить позже.
Здесь к классу прикрепляется наследование, и в дальнейшем каждый объект получит по одной копии унаследованных свойств и собственных свойств. Он образует жесткую жесткую иерархическую таксономию между родителем и потомком.
ООП на основе прототипа — это другой стиль ООП. Там, где методология программирования фокусируется на том, что объект делает, а не на том, чем он будет, не нужно предсказывать будущее.
Здесь наследование прикрепляется к живому рабочему объекту, который называется прототип или [[прототип]] или __proto__ и доступен для всех дочерних элементов. Объекты не получают копии унаследованного поведения, они получают объект-прототип и могут быть изменены позже. Он не образует жесткой и жесткой таксономии. Это так же эффективно, как наследование на основе классов.
Класс — это зарезервированное ключевое слово в JavaScript, это просто функция в фоновом режиме, действует как функция-конструктор.
Прототип является свойством традиционной функции (не стрелочной функции) , он копируется в свойство [[prototype]] нового объекта при создании экземпляра с этим класс или конструктор, к которому можно получить доступ с помощью , потому что [[прототип]] является скрытым свойством. Чтобы изменить или установить [[prototype]] объекта, мы используем Object.setPrototypeOf(, потому что прямое присвоение .__proto__ — плохой и медленный подход.
Мы проверим принцип ООП с помощью JavaScript на примерах, я также дам вам немного дополнительной информации и несколько трюков.
Еще раз обратите внимание, все в JavaScript является объектом
До этого…
Создание объекта по новому ключевому слову Создание объектов по новому ключевому слову в JavaScript Object() Array() и Function() — предопределенный конструктор, а 9012 3 MyObejctCreator() мой настраиваемый конструктор.
Также показано, как даже функция ( MyObejctCreator() ) может быть создана с явным вызовом функции конструктора Function() .
Итак, что такое конструктор? Конструктор — это метод (для класса) или функция, которая вызывается при создании экземпляра объекта. По соглашению об именах всегда используйте первую букву конструктора с заглавной буквы, чтобы легко было отличить обычную функцию от конструктора, потому что в JavaScript конструктор может быть любой функцией, которая не является функция стрелки .
Что происходит за сценой , так это то, что когда функция конструктора вызывается с ключевым словом new new , создается новый объект, который присоединяется к этой ссылке и автоматически возвращает объект в конце функции даже если мы не напишем.
Вот почему стрелочная функция не может создавать экземпляры объектов, потому что у них нет эта ссылка , потому что они не создают контекст выполнения, эта ссылка в функции стрелки лексически ограничена таким образом, вызов call() , apply() или bind() не влияет на него .
На изображении выше в строке 20 я использовал конструктор Function() для создания экземпляра функции, потому что функции в JavaScript тоже являются объектами. Function() принимает имена аргументов и тело функции как строки, как аргументы.
Вы заметили if(new.target == undefiend) ? new.target — это псевдосвойство или экзотическое свойство времени выполнения, указывающее на конструктор, с которым вызывается ключевое слово new . Он используется для проверки того, вызвала ли функция конструктора это ключевое слово new или нет.
ключевого слова Создание объекта с помощью класса в JavaScript ключевого слова класса такое же, как традиционная функция или функция конструктора (не функция стрелки) в JavaScript. Это просто синтаксический сахар, представленный в ES6.
Здесь вы можете увидеть идентификатор argumnets . argumetns — это объект, который автоматически создается в традиционных функциях и хранит все параметры, переданные функции при вызове. Это также объект Iterable, поэтому его можно использовать в цикле for…of.
Array.prototype.join.call() , Array является конструктором массива, а Array.prototype является прототипом объектов массива, в котором хранятся все методы массива.
Давайте немного узнаем, что прототип объект — это живой рабочий объект, который содержит поведение объекта, только прототип отвечает за наследование в JavaScript.
Теперь вы знаете, что поведение или метод массива хранятся в Array.prototype , и это объект, поэтому мы можем получить доступ к свойствам с помощью . (точка), поэтому для Array.prototype.join .
И call() — это предопределенный метод функционального объекта.
Используется для определения эта ссылка во время выполнения. Первым аргументом, который он принимает, является ссылка на этот , а затем все аргументы, которые должна выполнить основная функция, для которой call() она применила, разделенные запятыми , .
Итак, для Array.prototype.join.call(arguments, «-») arguments объект теперь является этой ссылкой join() и join() вызывается с аргументом « -” .
Object.Create() создание объекта с помощью object.create в javascript Object() — функция-конструктор для объектов. Он имеет метод create() , который создает объект, он принимает два аргумента: сначала объект прототипа , который будет установлен в качестве нового объекта __proto__ или [[prototype]] , или вы можете указать свойство прототипа и второго аргумента.
дескриптор, имя свойства и описание свойства которого будут применены к новому объекту.
Фабричная функция — это любая функция, которая при вызове возвращает новый объект.
Инкапсуляция JavaScript. Переменные-члены и методы сгруппированы вместе, только доступные или ограниченные объектом Переменные-члены и методы, или свойства объекта заключены в фигурные скобки {} или один объект.
имя и язык свойства доступны с эта ссылка , потому что имя и язык являются дочерними или связаны с obj . Нам нужно зайти внутрь объекта obj , чтобы получить к ним доступ.
Обратите внимание, что когда мы пишем
{}, конструкторObject()автоматически вызывается за сценой. То же для[]иМассив().
JavaScript удовлетворяет инкапсуляции
Прежде чем углубляться в абстракцию, знайте, что JavaScript не имеет зарезервированных ключевых слов для абстракции, а довольно умно использует знания JavaScript, такие как замыканий (для конструктора, фабричной функции) и для 9001 5 класс с префиксом # перед именем свойства. И это работает так же хорошо, как и должно быть.
Абстракция
с использованием класса Абстракция в JavaScript с использованием класса, создание закрытых элементов данных и методов В классе мы используем префикс # перед именем свойства, чтобы сделать элементы данных и методы закрытыми.
Посмотрите выше obj отображается пустым, потому что name , lang является членом obj , но они являются частными, а слоган (частный) и say() метод добавлен в прототип объект, поэтому показывая пусто, на самом деле нет.
Абстракция
с использованием функции-конструктора, Абстракция в JavaScript с использованием функции-конструктора и формированием замыкания для частных элементов данных и методовАбстракция
с использованием фабричной функции, Абстракция в JavaScript с использованием фабричной функции и формированием замыкания для частных элементов данных и методовВ случае функции конструктора и фабричной функции мы используем концепцию закрытия для создания закрытых элементов данных и методов.
В приведенных выше двух случаях мы не можем получить доступ к name , lang , id и slogan() , потому что они не являются свойствами obj . Они ограничены функцией, но сохраняются рефери из-за закрытия, поэтому мы можем получить к ним косвенный доступ.
И мы не можем добавить say() к прототипу, потому что прототип является общим объектом для всех их дочерних элементов, поэтому доступ к чему-либо из прототипа означает доступ извне, что означает, что свойство должно быть общедоступным.
Но вот say() обращается к приватному методу slogan() .
Кроме того, замыкание просто используется для создания приватных свойств, поэтому все, что требует доступа к приватным свойствам, должно быть определено, прежде чем закончится или потеряет свою область действия. Итак, методы абстракции просто отлично работают.
JavaScript satisfis Abstraction
JavaScript — это язык программирования, основанный на прототипах. Наследование выполняется с использованием живого объекта под названием прототип 9.0124 или [[prototype]] или __proto__ , которые можно изменить, заменить в любом месте кода, и изменения будут отражены во всех объектах, которые обращаются к этому [[prototype]] .
Наследование
с использованием класса, Демонстрация наследования в JavaScript с использованием классаНаследование
с использованием функции конструктора, Демонстрация наследования в JavaScript с использованием функции конструктора и прототипаНаследование
с использованием фабричной функции, Демонстрация наследования в JavaScript с использованием фабричной функции и прототипаВсе приведенные выше коды приведут к тому же результату
, что и все три приведенных выше примера кода Как было сказано ранее, наследование в JavaScript поддерживается живым рабочим объектом, который используется всеми дочерними элементами.
И прототип можно модифицировать и изменять, поэтому он не образует жесткой иерархии. Изменение прототипа отразится на всех детях.
Изменение и модификация прототипа
Изменение прототипа объекта и модификация объекта-прототипа в JavaScriptВы можете увидеть, что изменение и изменение прототипа может сделать с вашим кодом.
И подход, основанный на прототипах, и подход, основанный на классах, работают должным образом, тогда почему существуют два разных подхода?
Ну, силы, основанные на классах, которые вы планируете до того, как начнете, не имеют возможности модифицироваться позже, а основанные на прототипах позволяют планировать на ходу. У обоих есть свои плюсы и минусы, наследование на основе прототипов очень гибкое и простое, а наследование на основе классов позволяет вам выявлять ошибки раньше, что позволяет писать код без ошибок.
Если вы заметили, во всех приведенных выше примерах присутствует статический метод isPlant() . Это член класса, конструктора и фабричной функции, а не член новых объектов.
Он наследуется не от объектов, а от класса, конструктора и фабричной функции.
JavaScript satisfis Inhertance
Полиморфизм — одно и то же поведение объектов выполняется по-разному, когда они находятся в другом состоянии или контексте.
Подобно тому, как меняется личность человека в зависимости от ситуации, когда человек работает учителем, он может любить учить, но когда человек является родителем, он любит своего ребенка, это одно и то же. «поли» означает «много», а «морф» означает черты или характеристики.
Полиморфизм с использованием класса,
Демонстрация полиморфизма в JavaScript с использованием классаПолиморфизм с использованием функции-конструктора,
Демонстрация полиморфизма в JavaScript с использованием функции-конструктораПолиморфизм с использованием фабричной функции,
Демонстрация полиморфизма в JavaScript с использованием фабричной функции Цепочка прототипов. Что такое цепочка прототипов? Как следует из названия, цепь прототип или [[прототип]] или __proto__ объекта.
Когда мы наследуем, мы просто говорим, что присоединяем объект, который содержит некоторое поведение, то есть методы, к прототипу нового объекта . Прикрепленный объект теперь будет прототипом нового объекта .
Когда мы пытаемся что-то прочитать или записать в объект, JS-движок сначала будет искать это свойство в объекте. Если найдено, поиск остановится и будет возвращено свойство. В противном случае он перейдет к прототипу объекта, будет искать среди его свойств, если не будет найдено, затем перейдет к прототипу прототипа и так далее… пока не достигнет null если найден где-либо, он остановится на этом и вернет свойство, если не будет найден до конца, он вернет undefined
Поскольку в JavaScript все является объектом, последние два прототипа всего будут Object.prototype , а прототип объекта Object.prototype равен null .
Поскольку все вышеприведенные результаты кода одинаковы, их вывод будет,
вывод всех приведенных выше примеров кода полиморфизма Здесь, дочерний 9Метод 0123 loves() находится на прототипе дочернего объекта, а родительский (родительский) метод loves() находится на прототипе прототипа дочернего объекта.
Дочерний loves() находится первым перед родительским loves() , таким образом возвращается дочерний loves() . Это также называется затенением. Так работает полиморфизм в JavaScript.
Для класса в строке 20 используется super , это ключевое слово, используемое для вызова конструктора родительского класса, а также для ссылки на свойства родителя в случае конфликта имен. Работа здесь такая же, как показано в случае функции конструктора и функции фабрики в строках с номерами 23 и 22, соответственно, используемых __proto__.__proto__ для ссылки на свойства родителя. Итак,
JavaScript удовлетворяет полиморфизму
Итак, теперь мы увидели, что JavaScrit удовлетворяет всем методологиям объектно-ориентированного программирования (ООП).
Тогда почему JavaScript не является ООП языком? Это потому, что JavaScript не является языком программирования на основе классов? Или это потому, что наследование JavaScript основано на прототипе? Ответ — большое НЕТ на все вопросы.