PROGRAMMING

1. Imperative vs declarative

Декларативное программирование - это когда вы говорите, что вы хотите, а императивный язык-когда вы говорите, как получить то, что вы хотите.

Императивное программирование (от англ. imperative — приказ)

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

Программа — набор инструкций изменяющих состояние (данные). Мы говорим КАК выполнить задачу, описывает алгоритм, даем набор последовательных инструкций.

Для этой парадигмы характерно использование:

именованных переменных;
оператора присваивания;
составных выражений;
подпрограмм;
циклов.

К подвидам императивного программирования относят Процедурное и Объектно-ориентированное программирование (ООП).

Декларативное программирование

Это парадигма программирования, в которой задается спецификация решения задачи, то есть описывается, ЧТО представляет собой проблема и ожидаемый результат. Декларативные программы не используют состояния, то есть не содержат переменных и операторов присваивания. Программа — спецификация описывающая решение задачи.

К подвидам декларативного программирования относят Функциональное и Логическое программирование.

Useful link:

Агенда:

Чистота: чистые функции, нечистые функции, побочные эффекты
Состояние: с ним и без него
Неизменяемость и изменяемость
Императивное и декларативное программирование
Функции высшего порядка
Функциональное программирование
Observables: горячие и холодные
Реактивное программирование
Функциональное реактивное программирование

2. OOP - Abstraction - Inheritance - Encapsulation - Polymorphism

Объе́ктно-ориенти́рованное программи́рование (ООП) — методология программирования, в которой основными концепциями являются понятия объектов и классов. В центре ООП находится понятие объекта.

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

Зачем нам ООП?

Для упрощенного понимания логики.

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

Почему ООП не FP

Методология

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

Что такое класс?

Класс - это абстракция.

Абстракция

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

Абстракция означает использование простых вещей для описания чего-то сложного. Это способ скрыть детали реализации и показать пользователям только функциональность. Абстракция игнорирует нерелевантные детали и показывает только необходимые.

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

Важно помнить, что мы не можем создать экземпляр абстрактного класса.

Абстрактный класс

Базовый класс, который не предполагает создания экземпляров.

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

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

Инкапсуляция

Скрытие реализации от вне.

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

Методы:

С помощью ключевого слова class в ES2015
C помощью функции, которая возвращает объектный литерал
Инкапсуляция с использованием замыкания:

const createCounter = () => {
  // Переменная, определенная в области действия фабрики или конструктора
  // является приватной для этой функции.
  let count = 0;

  return ({
    // Любые другие функции, определенные в той же области, являются привилегированными:
    // Они имеют доступ к закрытой переменной `count`
    // определенной в любом месте их цепочки областей видимости (содержащей области действия функции).
    click: () => count += 1,
    getCount: () => count.toLocaleString()
  });
};

const counter = createCounter();

counter.click();
counter.click();
counter.click();

console.log(counter.getCount()); // "3"

4. Методы set() и get() в объекте. При попытке изменить поле напрямую (x.myVal = 2) ничего не произойдет. Сеттеры и геттеры - единственные пути в объект или из него.

Наследование

Способность классам-наследникам наследовать методы и поля класса-родителя. Мы избегаем необходимости переписывать один и тот же код, а также экономим пространство памяти, используя общие методы.

class Human {
  constructor(name) {
    this.name = name;
  }

  sayMyName() {
    return 'Hello, I am ' + this.name;
  }
}

class Men extends Human {
  constructor(name) {
    super(name)
  }
}
class Coder extends Human {
  constructor(name) {
    super(name)
  }
}

const alex = new Men('Alex');
const leo = new Coder('Leo');

alex.sayMyName() // Hello, I am Alex
leo.sayMyName() // Hello, I am Leo

Полиморфизм

Полиморфизм — это свойство системы использовать объекты с одинаковым интерфейсом без информации о типе и внутренней структуре объекта.

Этот принцип позволяет методам и функциям изменять свое поведение в зависимости от контекста.

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

Чтобы это произошло полиморфизм использует наследование.

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

class Human {
  constructor(name) {
    this.name = name;
  }

  say() {
    return `Hello, my name is ${this.name}, I like travelling`;
  }
}

class Men extends Human {
  constructor(name) {
    super(name)
  }
  // Берем метод say у родителя.
}

class Coder extends Human {
  constructor(name) {
    super(name)
  }

  say() {
    // Переопределяем метод родителя say для отображения нового значения.
    return `Hello, my name is ${this.name}, I like coding`;
  }
}

const alex = new Men('Alex');
const leo = new Coder('Leo');

alex.say() // "Hello, my name is Alex, I like travelling"
leo.say() // "Hello, my name is Leo, I like coding"

Useful link:

3. FP

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

Основной принцип ФП — оборачивать практически все в функции, писать множество маленьких многоразовых функций, а затем просто вызывать их одну за другой, чтобы получить результат вроде (func1.func2.func3) или в композиционном стиле func1(func2(func3())).

Кроме этого, структура функций должна следовать некоторым правилам, описанным ниже.

Принципы:

1. Все функции — чистые

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

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

2. Все функции — первого класса и высшего порядка

Эта концепция — не особенность ФП (она используется в Javascript, PHP и других языках) — но его обязательное требование. На самом деле, на Википедии есть целая статья, посвящённая функциям первого класса. Для того, чтобы функция была первоклассной, у неё должна быть возможность быть объявленной в виде переменной. Это позволяет управлять функцией как обычным типом данных и в то же время исполнять её.

Функции высшего порядка же определяются как функции, принимающие другую функцию как аргумент или возвращающие функцию. Типичными примерами таких функций являются map и filter.

3. Переменные неизменяемы

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

4. Относительная прозрачность функций

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

Пусть у нас есть Java-функция, которая складывает 3 и 5:

public int addNumbers(){
  return 3 + 5;
}
 
addNumbers() // 8
8            // 8

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

public void printText(){
  System.out.println("Hello World");
}
 
printText()   // Returns nothing, but prints "Hello World"

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

+Каррирование

+Частичное применение

4. OOP vs Functional

5. FRP

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

Функциональное реактивное программирование — это программирование в декларативном стиле с изменяющимися во времени значениями.

Функциональное реактивное программирование в своей реализации в JavaScript относится к программированию в функциональном стиле при создании и реагировании на потоки. В чисто функциональном программировании нет побочных эффектов. Для многих типов программного обеспечения (например, что-либо с взаимодействием с пользователем) побочные эффекты необходимы на некотором уровне.

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

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

Например, вы можете представить координаты мыши в виде пары целочисленных значений времени. Допустим, у нас было что-то вроде (это псевдокод):

x = <mouse-x>;
y = <mouse-y>;

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

Если мы затем сделаем некоторые вычисления, основанные на этом, результирующие значения также будут значениями, которые меняются со временем. Например:

minX = x - 16;
minY = y - 16;
maxX = x + 16;
maxY = y + 16;

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

rectangle(minX, minY, maxX, maxY)

А вокруг указателя мыши будет нарисован прямоугольник размером 32x32, который будет отслеживать его перемещение.

PreviousUnit Tests/TDD/BDD NextCLEAN CODE (principles, approaches)

Last updated 3 years ago

Was this helpful?