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

Оказывается, в JavaScript есть все необходимое для использования в качестве функционального языка. Нам просто нужно удалить из языка функции, начинающиеся с ключевого слова this.

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

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

Вот некоторые вещи, которые вы узнаете:

  • Как отключить «это» и включить неизменяемые объекты данных с помощью линтера
  • Как работать с неизменяемыми объектами и коллекциями
  • Как выполнять преобразование данных с помощью основных операций, таких как фильтр, сопоставление, сортировка или сокращение
  • Как использовать такие операторы, как if и switch, функционально
  • Как создавать конвейеры и использовать каррирование для передачи дополнительных данных
  • Как создавать и использовать функторы и монады
  • Как работать с обещаниями и наблюдаемыми
  • Понять архитектуру вяза

Введение

Функциональное программирование становится все более популярным, и эта книга направлена ​​на то, чтобы прояснить, как использовать JavaScript в качестве функционального языка.

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

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

JavaScript - это одновременно язык функционального программирования и язык, основанный на прототипах. Если мы избавимся от this, у нас останется JavaScript как функциональный язык программирования. Так даже лучше.

При этом мы можем удалить this из нашего кода, включив линтинг.

Вот пример файла конфигурации lint, отключающего ключевое слово this из приложения, созданного с помощью Create React App.

{
  'extends': ['react-app'],
  'plugins': [
      'immutable'
  ],
  'rules': {
      'immutable/no-this': 'error'
  }
}

JavaScript без this выглядит лучшим функциональным языком программирования.

Главы

  • Глава 01: Примитивы
  • Глава 02: Неизменяемые объекты данных
  • Глава 03: Функции
  • Глава 04: Массивы
  • Глава 05: Первоклассные функции
  • Глава 06: Заявления
  • Глава 07: Рекурсия
  • Глава 08: Конвейеры и каррирование
  • Глава 09: Функторы
  • Глава 10: Монады
  • Глава 11: Неизменяемые коллекции
  • Глава 12: Ленивые преобразования
  • Глава 13: Генераторы
  • Глава 14: Обещания
  • Глава 15: Наблюдаемые
  • Глава 16: Вязовая архитектура
  • Глава 17: Функциональная парадигма

Глава 1

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

Примитивы

К примитивным значениям относятся числа, строки, логические значения, null и undefined. Зарегистрируйте некоторые из этих примитивных значений в консоли.

console.log(1);
console.log('text');
console.log(true);

Все эти примитивные значения имеют тип. Мы можем найти тип значения с помощью оператора typeof. Проверьте некоторые из них.

console.log(typeof(1));
//'number'
console.log(typeof(''));
//'string'
console.log(typeof(true));
//'boolean'

Есть два типа номеров Number и BigInt. В основном мы собираемся использовать первую, в которой хранятся числа с плавающей запятой двойной точности. Важно знать, что арифметика с плавающей запятой неточна.

console.log(0.1+0.2);
//0.30000000000000004
console.log(0.1 + 0.2 === 0.3);
//false

Целочисленная арифметика имеет точность до 15 цифр. Мы можем решить указанную выше проблему, сначала умножив, а затем разделив.

console.log(1 + 2 === 3);
//true
console.log(0.1 * 10 + 0.2 * 10) / 10 === 3);
//true

BigInt используется для обозначения больших чисел. Мы можем создать такие числа, добавив n в конец целочисленного литерала.

console.log(12345678987654321n);

Строки - это тексты. Есть три способа определить строковое значение, одинарные кавычки, двойные кавычки и обратные кавычки.

'text'
'text'
`text`

Неопределенный - это тип с одним значением undefined. Null - это тип с одним значением null. Boolean - это тип с двумя значениями true и false.

Методы на примитивах

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

'TEXT'.toLowerCase();
//'text'

У нас есть доступ к существующим свойствам примитивов, но мы не можем их изменять или создавать новые. Например, свойство length возвращает размер строки.

'ABCDEFG'.length
//7
'ABCDEFG'.type = 'letters';
//Cannot create property 'type' on string 'ABCDEFG'

Единственные примитивы, которые не рассматриваются как объекты, - это null и undefined. Попытка вызвать для них метод вызовет ошибку.

null.toString();
//Cannot read property 'toString' of null

Неизменность

Неизменяемое значение - это значение, которое однажды созданное не может быть изменено.

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

' 123 '.trim();
//'123';

Метод trim не изменяет существующую строку. Создает новый.

Переменные

Нам нужно проводить различие между переменными и значениями. Переменные не являются значениями. В переменных хранятся значения.

Мы можем присваивать значения переменным. На данный момент переменные содержат эти значения. У переменных есть имя, и мы можем ссылаться на значение, используя имя переменной.

Мы сохраняем значение в переменной с помощью ключевого слова присваивания =. Переменные можно объявлять с помощью операторов let, var или const. Когда мы объявляем переменную без присвоения ей значения, она имеет значение по умолчанию undefined.

let x;
console.log(x);
//undefined

Значения не содержат переменных. Значения могут содержать другие значения.

У значений есть тип. Переменные имеют тип значения, которое они хранят. Переменные не привязаны к типу. Значение всегда имеет один и тот же тип. 1 всегда является числом, но следующая переменная x может сначала по номеру типа, а затем по строке типа.

let x;
x = 1;
x = '';

Когда значение, хранящееся в переменной, изменяется, тип переменной может измениться. Динамическая типизация означает, что тип переменной может изменяться во время выполнения. Это происходит только для переменных, объявленных с помощью let или var.

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

Спасибо за интерес к этой книге. Щелкните здесь, чтобы просмотреть образец.