Функциональный JavaScript
Опубликовано

Опубликовано

Draft!!!
Осторожно! Слабонервным, холерикам и беременным не читать - выносит мозг, меняет сознание!
function func(fn, arg1, arg2) {
return function () {
return fn.call(null, arg1, arg2);
};
}
Переменные - зло. Основная причина - это то, что они переменные т.е. меняют своё состояние во времени самым непредсказуемым образом. Проблемы начинаются когда переменных появляется много то за ними трудно уследить, а так же количество кода, логика которого зависит он них, и к статиб автор переменной никогда не может быть уверен как ее используют в будущем. Другими словами, закон Мерфи("Что может произойти то обязательно произойдет") в действии, любой кусок кода который имеет доступ к переменной может изменить самым непредсказуемым образом.
С появлением переменной появляется зависимость во времени до и после присваивания. Проблема в том что переменные приносят в систему понятие состояния. Как правило каждое состояние приносит нам по два метода для роботы с ним, классический пример, malloc и free, open и close, getCanvas и freeCanvas и т.д.
Каждую из перечисленных функций надо вызвать в правильном порядке и при том, если не вызвать функцию освобождения, то появляются проблемы часто сложно уловимые. Поэтому в мире столько ужастиков с утечкой памяти и множество методов борьбы с ним. С выделением памяти целая эпопея, поэтому люди придумали сборщики мусора которые решают созданную проблему вместо программистов, местами не очень хорошо~~, привет stop world~~. Но вот проблема, сборщика мусора нет для файлов, нет для холста... для многих вещей нет.
Пример с сменой состояния:
var s = 8,
q = 3;
function badFunction() {
// ...
s = s - 2;
// ...
q = 1/s;
// ...
return q + s;
}
badFunction();
Во-первых, в примере видно плохие имена переменных :) во-вторых, видно, как функция обращается к переменной s и меняет её состояние. Так что будет, если переменная s будет иметь значение 2? Да, верно программа "вылетит" с исключением, но только в текущем event loop. Следующий код, который будет читать значения s и q, получит значения в не консистентном состоянии, т.е. другие части программы могут не ожидать таких значений и могут работать неверно.
Поэтому желательно не использовать переменные или использовать их в наименьшей области видимости, насколько это возможно - чем меньше кода имеет доступ к переменной, тем лучше. В идеале время жизни переменной должно быть в пределах 5-15 линий кода. Время жизни переменной это "путь" от её создания до последнего использования. Но так как эта запись о функциях, то вернёмся к ним.
Первый способ, это вообще не описывать сигнатуру функции и положиться на то, что названия аргументов достаточно понятны для быстрого понимания их назначения. Такой подход хорош для маленьких проектов, где автор кода всегда под рукой и может проконсультировать. Пример:
function sum3(a, b, c) {
return a + b + c;
}
Следующий, более JavaScript подход, представляет JSDoc. Подход более лучший, так как позволят не только описать сигнатуру функций, но и дополнительную информацию, на основании которой можно сгенерировать документацию. Более того, некоторые IDE умеют читать этот формат и использовать для подсказок при разработке, что довольно удобно. Основной минус так это то, что он довольно многословен, и иногда читать смесь из документации и кода не очень-то и удобно. Пример:
/**
* Сумирует три числа
*
* @param {Integer} a первый аргумент
* @param {Integer} b второй аргумент
* @param {Integer} c последний аргумент
* @return {Integer}
*/
function sum3(a, b, c) {
return a + b + c;
};
И последний вариант, на котором и остановимся. Предназначен он для описания только самых сигнатур и не более. Не многословен, и нет поддержки в IDE (пока нет). Начнём с того, что он "украден" в правильных функциональных языков где каррирование у всех функций по умолчанию. Поэтому далее будем рассматривать все функции как каррированые. Пример сигнатуры:
//+ sum3 :: Int -> Int -> Int -> Int
function sum3(a, b, c) {
return a + b + c;
};
Как видно с примера, функция работает с четырьмя параметрами первые три это собственно входные параметры, а четвёртый это результат работы.
Ах, да важное замечание: в функциональных языках функции всегда возвращают что-нибудь. Если функция ничего не возвращает, то по факту она ничего не делает... и да, не забываем что в идеале функции чистые, т.е. ничего не изменяют (DOM, ввод-вывод, AJAX и т.п.). Функции также не должны изменять значения, которые переданы как аргументы. Если все же есть необходимость их изменить, тогда нужно создать копию оригинального значения и изменить его. Да, это немного расточительно по отошению к памяти, но более безопасно.
Ещё пример:
//+ toUpperCase :: String -> String
function toUpperCase(s) {
return s.toUpperCase();
}
Более сложный пример:
//+ map :: (a -> b) -> [a] -> [b]
function map(fn, arr) {
return arr.map(fn);
};
Думаю, этот случай надо более детально рассмотреть. Типов a и b не существует в природе JavaScript, это просто мнемоническое обозначение что тип может быть любой. Квадратные скобки вокруг означают, что это массив элементов a. Так же с последнего примера видно (a -> b), что первый аргумент функции есть функция в которую будет передан один элемент с массива [a], и она должна вернуть значение b, которое впоследствии будет помещено в массив элементов [b].
Несколько примеров для самостоятельного изучения:
//+ indexOf :: a -> [a] -> Int
function indexOf(value, a) {
return a.indexOf(value);
};
//+ reduce :: (b -> a -> b) -> b -> [a] -> b
function reduce(fn, acc, a) {
return a.reduce(fn, acc);
};
//+ charAt :: Int -> String -> String
function charAt(i, s) {
return s.charAt(i);
};
var oneAndSecondFn = compose(secondFn, oneFn);
Композиция — процесс применения одной функции к результату другой.
fn1(fn2(fn3(value)));
// равносильно
compose(fn1, fn2, fn3)(value);
Нечто похожее существует уже довольно давно в *nix системах и называется конвеером (pipe).
$ cat file.txt | grep ^boo | foo
Смысл здесь в том, что для достижения конечного результата используется несколько маленьких утилит, которые делают маленький, но необходимый кусок работы. Как в этом примере, одна утилита читает текстовый файл cat file.txt и выводит на экран, но вывод на экран перехвачен и направлен на вход другой утилите grep ^boo, которая в свою очередь фильтрует полученные данные и опять выводит на экран, где они которые опять перехватываются и передаются на вход утилите foo, которая делает с ними тоже что-то светлое и хорошее, и после снова выведет на экран но на этот раз уже успешно, так как вывод не перенаправлен, поэтому пользователь видит результат работы.
Аналогично работает функция compose: переданные ей функции она сохраняет в массиве и возвращает новую функцию, и при её вызове будет выполняться последняя функция из переданных в compose и ей же будут переданные аргументы. В свою очередь результат работы последней функции будет передан предпоследней. И так до самой первой функции, результат которой будет возвращён.
С помощью такого подхода можно необходимую логику декомпозировать (розбить на более мелкие части), в результате у нас будет увеличено переиспользование кода, а значит багам будет сложнее скрыться и разработка буте идти быстрее.
Очень важно отметить, что композиция/декомпозиция способствует более абстрактному коду. Абстракция в свою очередь способствует быстрой разработке, (но!) увеличивает время на обучение. Другими словами менее опытные разработчики будут тратить больше времени на обучение.
var values = [1, 2, 3, 4, 5].map(function (item) {
return item + 1;
});
values; // => [2, 3, 4, 5, 6]
Для всех, кто работет з JavaScript продолжительное время, хорошо знаком метод map для массивов. Если же немного подзабыли, то напомню: он обходит весь массив и к каждому элементу применяет функцию, переданную первым аргументом, создает новый массив и в него помещает элементы/значения, которые возвращает функция. Так вот, этот метод - функтор.
Если взглянуть на него с немного большей высоты, то функтор это метод который знает внутренне устройство объекта (в нашем случае это Array), умеет извлечь оттуда каждый элемент, передать в обрабатывающую функцию и обработанные элементы поместить обратно в объект такого же типа.
Это можно ипользовать, например, для DOM или структуры дерева. Определить метод map, который обходит дерево, применяет функцию для каждого элемента и снова строит аналогичное дерево с возвращенных значений.
lentghTree = namesTree.map(function (name) {
return name.length;
});
*
/ \
/ \
* "Vova"
/ \
/ \
/ \
/ \
"Jon" "Nike"
Трансформируется в:
*
/ \
/ \
* 4
/ \
/ \
/ \
/ \
3 4
И вот последний еще более приземленный пример:
function Identity(value) {
this.value = value;
}
Identity.prototype.map = function (fn) {
// передаем значение и создаем новый
// екземпляр с таким же классом
return new Identity(fn(this.value))
};
Очень интересный доклад, рекомендую посмотреть, хотя если нет времени и/или желания смотреть 40 минутный доклад, ниже будет краткое содержание.
Так в чем же проблема самого Underscore? Underscore позиционируется как библиотека с функциональным подходом. но проблема здесь кроется в параметрах, точнее их последовательности. Выше была описана основа функционального подхода - каррирование и композиция, так вот в Underscore сложно делать композицию через последовательность аргументов. Потому что в нем при вызове метода надо указать первым аргументом данные которые нужно обработать и после функцию которая будет обрабатывать. Это исключает возможность использовать каррирование для создания необходимых функций на лету.
var isOdd = function () {
return item % 2;
};
var filtredData = _.filter([1, 3, 4, 5, 6], isOdd);
В этом и кроется проблема. Здесь нам нужна переменная для сохранения данных, которые будут обработаны дальше. Что если мы сделаем функцию следующего вида:
var filter = curry(function (fn, arr) {
return arr.filter(fn);
});
Первое что нужно отметить мы сделали её каррированой и второе поменяли местами аргументы. И если теперь сделаем так:
var filterOdd = filter(isOdd);
У нас будет функция, которой можно передать любой массив (или не очень массив а все у чего есть метод filter) и она вернёт фильтрованный. Думаю, её мощь пока не очень видна - тогда немного усложним.
var showResult = curry(function (selector, data) {
// пример для простоты с использованием jQuery
var $el = $(selector);
$.each(data, $el.append.bind($el));
}),
processData = function (item) {
return item + (item * 42);
},
processAndShow = compose(
showResult('#data_block'),
map(processData), // "православный" и каррированый map
filterOdd // или filter(isOdd)
);
processAndShow([1, 3, 4, 5, 6]);
Небольшое напоминание, что функции, скормленные compose, будут исполнены в обратном порядке. Иногда в библиотеках для упрощения делают функцию pipe, в которой аргументы-функции идут в прямом порядке.
Как видно из примера, у нас нигде явно нет передаваемых переменных с данными, но они передаются от одной функции к другой, и результат уже выводиться пользователю. Таким способом можно сделать много работы уже проверенными функциями, которые чётко делают свою роботу и без побочных эффектов (вывод пользователю это побочный эффект, но мы пока закроем на это глаза). Как помним, showResult каррированая и ей можно скормить аргументы по один, и когда она уже будет "сытая" - выдаст результат.
Более того с таким подходом можно делать и асинхронные операции:
var getJsonByUrl = function (url) {
// ... тело скрыто для интриги
};
var getProcessAndShow = compose(
showResult('#data_block'),
map(processData), // "православный" и каррированый map
filterOdd, // или filter(isOdd)
getJsonByUrl
);
getProcessAndShow('//myserver/getdata.json');
Промисы? Колбэки? Асинхронный код? Не, не слышал. Но вот тут есть небольшая проблема: а что если сервер недоступен? Или данные должен был ввести пользователь, а их нет? Ой, беда...
Хотя если подумать не такая уже и беда, все можно решить в функциональном стиле. Для этого в нас есть (будут?) монады! Посмотрим, как можно определить монаду maybe:
function Maybe(value) {
this.value = value;
}
Maybe.prototype.map = function (fn) {
if (this.value === null || this.value === undefined) {
return new Maybe(null);
}
return new Maybe(fn(this.value));
};
Maybe.prototype.isNothing = function () {
return this.value === null || this.value === undefined;
};
Maybe.prototype.toString = function () {
return 'Maybe(' + this.value + ')';
};
Теперь можно безопасно работать с потенциально отсутствующими данными:
var result = new Maybe(user)
.map(function(u) { return u.profile; })
.map(function(p) { return p.email; })
.map(function(e) { return e.toLowerCase(); });
if (!result.isNothing()) {
console.log('Email: ' + result.value);
} else {
console.log('Email not found');
}
Функциональное программирование в JavaScript открывает новые возможности для написания более надежного, предсказуемого и легко тестируемого кода. Конечно, переход от императивного стиля к функциональному требует времени и практики, но результат того стоит.
Основные принципы, которые стоит помнить:
Помните: красота функционального программирования не в том, чтобы использовать все возможные абстракции, а в том, чтобы делать код более понятным и надежным.