МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ КЫРГЫЗСКОЙ

РЕСПУБЛИКИ
Кыргызский Национальный Университет имени Ж. Баласагына
Институт Компьютерных Технологий и Искусственного
интеллекта

Информационные системы и технологии

СРС
По дисциплине: «Разработка современных фронтенд web
приложений»
На тему: «Инкапсуляция свойств. Геттеры и сеттеры»

Выполнил студент 2-курса

Группы ИСТ-1-23
Акматов Рамазан

БИШКЕК 2024
Оглавление
1. Введение в инкапсуляцию свойств.....................................................3
2. Принципы инкапсуляции в программировании.................................4
3. Геттеры: определение и использование..............................................6
4. Сеттеры: определение и использование.............................................7
5. Реализация геттеров и сеттеров в JavaScript......................................9
6. Преимущества и недостатки использования геттеров и сеттеров..10
7. Примеры использования геттеров и сеттеров..................................12
8. Заключение о значимости инкапсуляции в разработке...................15
1. Введение в инкапсуляцию свойств

Инкапсуляция свойств — это один из основных принципов

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

2. Принципы инкапсуляции в программировании

Инкапсуляция является одним из основополагающих принципов

объектно-ориентированного программирования (ООП) и играет
жизненно важную роль в разработке программного обеспечения. Она
представляет собой механизм, позволяющий скрыть внутренние детали
реализации объекта и обеспечивать доступ к его состоянию только
через специально определенные методы. Принцип инкапсуляции
способствует созданию высококачественного, поддерживаемого и
масштабируемого кода. Одним из ключевых аспектов инкапсуляции
является разделение интерфейса объекта и его реализации. Это
означает, что пользователи объекта взаимодействуют с ним через
публичные методы (геттеры и сеттеры), не заботясь о том, как эти
методы реализованы. Такое отделение позволяет изменять внутреннюю
реализацию без влияния на код, который использует этот объект, что
значительно упрощает процесс отладки и модификации программ.
Инкапсуляция также способствует повышению безопасности и
целостности данных. Закрывая доступ к внутренним переменным
объекта, программист может контролировать, как и когда эти
переменные изменяются, что снижает риск ошибок и непредвиденных
последствий. Например, если мы имеем объект, который содержит
чувствительные данные, предоставление доступа к ним только через
методы, а не напрямую, позволяет реализовать дополнительные
проверки и валидацию, что защищает данные от некорректного
использования. Ещё одним важным принципом инкапсуляции
является возможность реализации абстракции. Поскольку пользователи
объекта взаимодействуют только с его интерфейсом, они могут
рассматривать объект как "черный ящик". Это позволяет
разработчикам сосредоточиться на высокоуровневых концепциях, не
отвлекаясь на детали реализации, что делает код более читабельным и
структурированным. Также инкапсуляция помогает организовать код,
разделяя его на логические модули. Каждый модуль может быть
независимым, что упрощает тестирование, рефакторинг и повторное
использование кода. Весь код становится более гибким и адаптивным к
изменениям, так как модули могут быть изменены или обновлены без
необходимости пересмотра всей системы. В итоге, инкапсуляция в
программировании выступает в роли важного инструмента,
позволяющего создавать устойчивые, безопасные и легко
поддерживаемые приложения. Этот принцип помогает разработчикам
мыслить более абстрактно, фокусироваться на решении задач, а не на
реализации.

3. Геттеры: определение и использование

Геттеры – это специальные методы в объектно-ориентированном

программировании, которые позволяют получать значения свойств
объекта. Они дают возможность пользователю взаимодействовать с
внутренними данными объекта, не затрагивая его реализацию. В
JavaScript геттеры создаются с помощью ключевого слова `get`, и их
основная задача заключается в предоставлении доступного интерфейса
для получения свойств объекта. Определение геттера обычно
происходит в момент создания объекта. Вот пример: ```javascript const
person = { firstName: 'John', lastName: 'Doe', get fullName() {
return `${[Link]} ${[Link]}`; } };
[Link]([Link]); // John Doe ``` В данном коде `fullName`
является геттером, который объединяет свойства `firstName` и
`lastName` в одно полное имя. При вызове `[Link]`
выполняется метод, определенный как геттер, и возвращается
результат без необходимости вызывать метод напрямую.
Использование геттеров в JavaScript имеет несколько преимуществ.
Прежде всего, они помогают изолировать внутренние механизмы
работы объекта. Это позволяет, например, изменять реализацию
хранимых данных, не затрагивая код, который использует эти данные.
При необходимости можно добавить в геттер валидацию или
преобразование данных. Еще одним преимуществом является
возможность создания производных свойств. Геттеры можно
использовать для вычисления значений на основе других свойств
объекта, как в примере с `fullName`. Это упрощает следование
принципу инкапсуляции, сохраняя структуру объекта компактной и
понятной. Геттеры также делают код более читаемым, так как
использование свойства объекта вместо вызова метода придает более
естественное ощущение уникальности доступа к данным. Например,
свойство `[Link]` выглядит более интуитивно понятным, чем
`[Link]()`. Это упрощает работу с данными и делает код
более «человеко-читаемым». Однако следует помнить, что избыточное
использование геттеров может привести к снижению
производительности, особенно если их реализация включает в себя
сложные вычисления или обращения к внешним ресурсам. В таких
случаях рекомендуется carefully 考虑 их использование. Таким образом,
геттеры являются мощным инструментом в JavaScript, который
позволяет создать более чистый и поддерживаемый код, пряча детали
реализации и предоставляя простой интерфейс для взаимодействия с
данными объектов.

4. Сеттеры: определение и использование

Сеттеры — это специализированные методы, используемые в

объектно-ориентированном программировании для установки значений
свойств объекта. Они дают разработчику возможность контролировать
процесс изменения данных, обеспечивая большую гибкость и защиту
от некорректного ввода. В контексте JavaScript методы-сеттеры
позволяют внедрять логику, которая будет выполняться каждый раз
при попытке установить значение определенного свойства объекта.
Определение сеттера в JavaScript осуществляется с помощью
ключевого слова `set`, за которым следует имя свойства и тело метода.
Сеттер принимает один параметр, который представляет новое
значение, которое нужно присвоить свойству. В процессе вызова
сеттера можно включать различные проверки, такие как валидация
данных, выполнение дополнительных операций или обработка ошибок.
Примером использования сеттера может служить следующий код:
```javascript class User { constructor(name) { this._name =
name; } get name() { return this._name; } set
name(newName) { if (typeof newName === 'string' &&
[Link] > 0) { this._name = newName; } else {
[Link]('Invalid name'); } } } const user = new User('Alice');
[Link]([Link]); // Alice [Link] = 'Bob'; // Устанавливаем новое
имя [Link]([Link]); // Bob [Link] = ''; // Некорректное имя ```
В этом примере сеттер `name` проверяет, что `newName` является
строкой и непустым значением. Если входные данные не проходят
проверку, происходит вывод сообщения об ошибке, и значение
свойства остаётся неизменным. Сеттеры также могут использоваться в
сочетании с геттерами для создания удобного API для работы с
объектами. Это позволяет скрыть внутреннюю реализацию и
предоставляет разработчикам простой интерфейс для взаимодействия с
объектом, улучшая инкапсуляцию данных и повышая безопасность.
Кроме того, сеттеры могут быть полезны в таких случаях, когда
необходимо выполнить дополнительные вычисления или триггерные
действия при изменении значений. Например, можно автоматически
обрабатывать связанные свойства или обновлять пользовательский
интерфейс на основе изменений в данных. Таким образом, сеттеры
являются мощным инструментом в арсенале разработчика, позволяя
ему контролировать процесс изменения свойств объектов и улучшать
надежность кода за счет валидации и других проверок.

5. Реализация геттеров и сеттеров в JavaScript

Геттеры и сеттеры в JavaScript — это специальные методы,

которые позволяют управлять доступом к свойствам объектов,
обеспечивая инкапсуляцию данных. Они позволяют разработчику
контролировать, как свойства объекта устанавливаются и считываются,
что делает код более безопасным и поддерживаемым. Рассмотрим, как
реализуются геттеры и сеттеры в JavaScript, и приведем примеры их
использования. В JavaScript геттеры и сеттеры определяются с
помощью синтаксиса объектного литерала или через классы. Геттеры
задаются с использованием ключевого слова `get`, а сеттеры — с
использованием ключевого слова `set`. Геттеры могут возвращать
значения свойства, в то время как сеттеры могут принимать значения и
выполнять дополнительные действия при их установке. ### Пример
реализации геттера и сеттера в объектном литерале: ```javascript const
person = { firstName: 'John', lastName: 'Doe', get fullName() {
return `${[Link]} ${[Link]}`; }, set fullName(name) {
[[Link], [Link]] = [Link](' '); } };
[Link]([Link]); // John Doe [Link] = 'Jane Smith';
[Link]([Link]); // Jane [Link]([Link]); //
Smith ``` В данном примере создается объект `person` с геттером
`fullName`, который возвращает полное имя, и сеттером `fullName`,
который разбивает строку и устанавливает значения `firstName` и
`lastName`. ### Пример реализации через классы: Геттеры и сеттеры
также можно использовать в классах, что позволяет применять
инкапсуляцию на уровне объектно-ориентированного
программирования. ```javascript class Rectangle { constructor(width,
height) { this._width = width; this._height = height; } get
area() { return this._width * this._height; } set width(value) {
if (value <= 0) throw new Error('Width must be positive'); this._width =
value; } set height(value) { if (value <= 0) throw new
Error('Height must be positive'); this._height = value; } } const rect
= new Rectangle(10, 20); [Link]([Link]); // 200 [Link] = 15;
[Link]([Link]); // 300 ``` В этом примере класс `Rectangle` имеет
геттер `area` для вычисления площади прямоугольника и сеттеры для
установки `width` и `height`. В сеттерах предусмотрена проверка,
обеспечивающая корректность данных. ### Заключение Геттеры и
сеттеры в JavaScript являются мощными инструментами для
управления доступом к свойствам объектов. Они обеспечивают
контроль над тем, как значения устанавливаются и получаются, что
способствует лучшей инкапсуляции и упрощению обслуживания кода.
Используя их, разработчики могут лучше структурировать свои
программы, избегая несанкционированного доступа к внутренним
свойствам объектов и уменьшая вероятность ошибок, связанных с
неправильным использованием данных.

6. Преимущества и недостатки использования геттеров и сеттеров

Геттеры и сеттеры в JavaScript представляют собой мощные

инструменты для инкапсуляции и управления доступом к свойствам
объектов. Их использование имеет ряд преимуществ, но также и
недостатков, которые важно учитывать при разработке. Одним из
основных преимуществ является улучшение контроля над доступом к
данным. С помощью геттеров и сеттеров разработчики могут
определять, как свойства объекта должны изменяться или извлекаться.
Например, перед установкой значения свойства в сеттере можно
добавить логику валидации, предотвращая присвоение некорректных
данных. Это позволяет поддерживать целостность данных и
обеспечивает более чистый код. Геттеры и сеттеры также
способствуют инкапсуляции, позволяя скрыть внутреннюю
реализацию объекта от внешнего мира. Пользователи объекта могут
взаимодействовать с ним только через эти методы, что позволяет
изменить внутреннюю структуру без воздействия на код, который
использует объект. Это делает код более гибким и устойчивым к
изменениям. Кроме того, наличие геттеров и сеттеров позволяет
использовать вычисляемые свойства. Например, геттер может
возвращать значение, основанное на других свойствах объекта, что
позволяет динамически получать актуальные данные без
необходимости явного хранения их в отдельном свойстве. Тем не
менее, у геттеров и сеттеров есть и свои недостатки. Во-первых, их
использование может привести к более сложному коду, особенно если
условия в геттерах и сеттерах становятся избыточными. Это может
затруднить понимание кода, особенно для других разработчиков,
которые могут не сразу осознать, что свойства являются лишь
обертками над методами. Во-вторых, производительность может
пострадать, особенно если геттеры и сеттеры содержат тяжелые
вычисления. В ситуациях, когда свойства часто запрашиваются,
постоянные обращения к геттерам могут замедлить работу
приложения. Разработчикам следует внимательно планировать, какие
операции следует выполнять в геттерах и сеттерах, чтобы избежать
лишней нагрузки на производительность. Наконец, избыточное
использование геттеров и сеттеров может сделать код менее
очевидным. Если свойства объектов становятся закрытыми, это может
осложнить их отладку и тестирование, так как разработчикам придется
понимать и отслеживать дополнительные методы, чтобы выяснить, что
происходит с данными. В заключение, геттеры и сеттеры в JavaScript
приносят как значительные преимущества, так и потенциальные
недостатки. Они обеспечивают контроль, инкапсуляцию и гибкость, но
привносят сложность и могут негативно сказаться на
производительности, если используются неразумно. Важно взвешивать
все «за» и «против» при проектировании архитектуры приложений,
чтобы максимально эффективно использовать эти конструкции.

7. Примеры использования геттеров и сеттеров

Геттеры и сеттеры в JavaScript предоставляют удобный и

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

8. Заключение о значимости инкапсуляции в разработке

Инкапсуляция является одной из основополагающих концепций

объектно-ориентированного программирования, играя ключевую роль
в создании надежных, масштабируемых и поддерживаемых
программных систем. Заключение о значимости инкапсуляции в
разработке можно сформулировать через несколько основных
аспектов, которые подчеркивают ее важность. Во-первых,
инкапсуляция позволяет скрывать внутренние детали работы объектов,
предоставляя только интерфейсы, которые можно использовать для
взаимодействия с ними. Это сокрытие реализации обеспечивает защиту
состояния объекта от неправильных изменений, что особенно важно в
сложных системах, где множество компонентов может
взаимодействовать друг с другом. Грамотное использование геттеров и
сеттеров позволяет обеспечить контроль над доступом к свойствам
объекта, гарантируя, что они могут быть изменены только через
определенные методы, что в свою очередь снижает вероятность
ошибок и упрощает отладку. Во-вторых, инкапсуляция способствует
улучшению читаемости и понятности кода. Когда внутренние детали
объекта скрыты за четко определенными интерфейсами, разработчики
могут сосредоточиться на бизнес-логике, не отвлекаясь на реализацию.
Это упрощает процесс совместной работы в команде, поскольку
каждый разработчик может работать с определенными классами и
модулями, не зная их внутреннего устройства, что упрощает
интеграцию и тестирование. Кроме того, инкапсуляция поддерживает
принцип единственной ответственности, позволяя разработчикам
разбивать сложные системы на более мелкие, управляемые части.
Каждый класс или модуль может отвечать только за свои собственные
данные и поведение, что делает систему более модульной и легкой в
сопровождении. Когда приходит время вносить изменения или
расширять функционал, разработчики имеют возможность работать
над отдельными компонентами, не опасаясь непредвиденных
последствий для всей системы. Наконец, важность инкапсуляции
также выражается в ее способности поддерживать гибкость и
масштабируемость приложений. Легко заменить или обновить
внутреннюю реализацию без воздействия на внешний интерфейс, что
позволяет проектам адаптироваться к изменяющимся требованиям
бизнеса. Это является критически важным в современном мире
разработки, где изменения происходят быстро, и приложения должны
оставаться актуальными и конкурентоспособными. Таким образом,
инкапсуляция представляет собой мощный инструмент в арсенале
разработчиков, обеспечивая надежность, читаемость и гибкость
программных систем, что делает ее одной из ключевых практик в
современном программировании.