Вы находитесь на странице: 1из 10

ООП

Три кита объектно-ориентированного


программирования: Инкапсуляция, Наследование,
Полиморфизм

Инкапсуляция — это принцип сокрытия информации, путем


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

attr_reader : height, :weight # Для getter


attr_writer : height, :weight # Для setter
attr_accessor : height, :weight # Для getter и setter

Наследование заключается в передачи всей структуры


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

Полиморфизм - это свойство объектов с одинаковой


спецификацией иметь различную реализацию
есть тип транспорта - автомобиль и марки автомобилей -
полиморфные объекты. Так, например, само по себе понятие
"автомобиль" абстрактно, а вот если уже говорить о
конкретной марке, то абстрактность исчезает. Это будет
хорошо заметно, если взять "Запорожец" и "Роллс-Ройс". Эти
объекты сильно отличаются друг от друга, но тем не менее
оба они являются наследниками абстрактного понятия
"автомобиль". Кардинальные отличия двум этим маркам
придал именно полиморфизм.
Git
Разница между Git pull vs Git merge

При использовании Git pull он будет сливать любые


внесённые commit в ветку, в которой вы сейчас работаете.
Команда git pull автоматически сливает commit, не давая вам
сначала просмотреть их. Может приводит к частым
конфликтам.

Git pull - выкачает все изменения из удаленной ветки

Git merge

Git merge принимает содержимое ветки, где мы писали код и


объединяет их с master веткой. В этом процессе изменяется
только master ветка. История исходных веток остается
неизменной.
Git merge x_branch - применит изменения из ветки x_branch к
текущей ветке, если не возникнет конфликтов

Git Rebase

Git rebase — еще один способ перенести изменения из одной


ветки в другую. Rebase сжимает все изменения в один «патч».
Затем он вносить все изменения в master ветку.

В отличие от merge, rebase перезаписывает историю, так как


она передает завершенную работу из одной ветки в другую. В
процессе устраняется нежелательная история.
Что такое Git chery-pick?

Git chery-pick - забираешь commit из одной ветки в другую,


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

Для чего нужен Git amend?

Эта команда откроет сообщение вашего последнего commit


для того, чтобы вы могли его исправить. Будет изменен
последний commit и в него будут добавлены файлы

Для чего нужно использовать Git stash?

Эта операция берет изменённое состояние вашей рабочей


директории, то есть изменённые файлы и изменения, и
сохраняет их в хранилище незавершённых изменений,
которые вы можете в любое время применить обратно.
SQL
Связи

Связь many-to-many

Связь многие ко многим подразумевает, что записи в одной


таблице может иметь множество ссылок на другую таблицу и
наоборот. Для такой связи нужно создавать дополнительную
таблицу, которая сведет связь many-to-many до связи one-to-
many

Для примера предположим, обувь может быть нескольких


типов (кроссовки-кеды или туфли-мокасины). Может пример
и не самый удачный, однако для тренировочных целей будет
то, что нужно.

Связь one-to-one

Данный тип связей встречает не часто. В этом случае объекту


одной сущности можно сопоставить только один объект
другой сущности. Например, на некоторых сайтах
пользователь может иметь только один блог. То есть
возникает отношение один пользователь - один блог.

Связь one-to-many

Это наиболее часто встречаемый тип связей. Когда мы


говорим о связи one-to-many то это означает: что одной
записи в таблице может отвечать множество записей другой
таблицы. Например, у одного поставщика может быть много
обуви.
JOINS в SQL

(INNER) JOIN: возвращает записи, имеющие совпадающие


значения в обеих таблицах
Left (OUTER) JOIN: возвращает все записи из левой таблицы
и совпадающие записи из правой таблицы
RIGHT (OUTER) JOIN: возвращает все записи из правой
таблицы и совпадающие записи из левой таблицы
FULL (OUTER) JOIN: возвращает все записи, когда есть
совпадение в левой или правой таблице

Scope
http://rusrails.ru/active-record-query-interface (15 заметка)

CRUD
https://guides.firstdraft.com/crud-with-ruby#crud-with-ruby
SOLID
SOLID это свод пяти основных принципов OOP.

Принципы
1. Single Responsibility Principle (Принцип единственной
ответственности)
2. Open Closed Principle (Принцип
открытости/закрытости)
3. Liskov Substitution Principle (Принцип подстановки
Барбары Лисков)
4. Interface Segregation Principle (Принцип разделения
интерфейса)
5. Dependency Inversion Principle (Принцип инверсии
зависимостей)

Первый принцип SRP

Как он устроен?

Говоря проще принцип SRP, состоит в том, что каждый класс


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

В чем может быть проблема этого принципа?

Чрезмерная любовь к SRP ведет к обилию мелких


классов/методов и усложняет логику между ними.
Второй принцип OCP

Как он устроен?

Каждый класс должен быть закрыт для изменения и открыт


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

В чем может быть проблема этого принципа?

Чрезмерная любовь к OCP ведет к сложным решениям с


чрезмерным числом абстракции.

Третий принцип LSP

Как он устроен?

Поведение наследуемых классов должно быть ожидаемо для


кода, использующие переменные базового класса Или, иначе
говоря, для класса S является подтипом T, то подтип T можно
спокойно заменить подтипом S без каких-то фатальных
изменений.

В чем может быть проблема этого принципа?

Данный анти-принцип проявляется либо в чрезмерном


количестве наследования, либо в его полном отсутствии, в
зависимости от опыта и взглядов местного главного
архитектора.
Четвертый принцип ISP

Как он устроен?

Классы должны быть ограниченны более узким интерфейсом.


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

В чем может быть проблема этого принципа?

Интерфейсы классов разбиваются на слишком большое число


составляющих, что делает их неудобными для использования
всеми клиентам

Пятый принцип DIP

Как он устроен?

Зависимости должны строятся вокруг интерфейсов, а не


деталей. Считается что это принцип возник из-за OCP и LSP.
Код, написанный по двум вышеперечисленным принципам,
должен быть читаемым и содержать четко разделенные
абстракции. Он также должен быть расширяемым, а дочерние
классы легко заменяемыми другими экземплярами базового
класса.

В чем может быть проблема этого принципа?

Интерфейсы выделяются для каждого класса и пачками


передаются через конструкторы. Понять, где находится
логика становится практически невозможно.
HTTP методы для CRUD

Create = PUT with a new URI


POST to a base URI returning a newly created URI
Read = GET
Update = PUT with an existing URI
Delete = DELETE

POST Creates a new resource.


GET Retrieves a resource.
PUT Updates an existing resource.
DELETE Deletes a resource.

https://www.restapitutorial.com/lessons/httpmethods.html