В разделе Функциональное программирование в 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
объявляет переменные, которые нельзя переназначить, поэтому они не могут изменить свой тип.
Спасибо за интерес к этой книге. Щелкните здесь, чтобы просмотреть образец.