Как устроено приложение JavaScript, основанное на функциональном программировании?

Вы должны прочитать этот вопрос:

Javascript как функциональный язык

Есть много полезных ссылок, в том числе:

• Используйте методы функционального программирования для написания элегантного JavaScript
• Маленький JavaScripter
• JavaScript высшего порядка
• Красноречивый JavaScript, глава 6: Функциональное программирование

Теперь на мое мнение. Многие люди неправильно понимают JavaScript, возможно потому, что его синтаксис похож на синтаксис большинства других языков программирования (где Lisp / Haskell / OCaml выглядят совершенно иначе). JavaScript не объектно-ориентированный, это фактически язык на основе прототипов < / а>. У него нет классов или классического наследования, поэтому его не стоит сравнивать с Java или C ++.

JavaScript может быть лучше по сравнению с Lisp; у него есть замыкания и первоклассные функции. Используя их, вы можете создавать другие методы функционального программирования, такие как частичное приложение (каррирование ).

Возьмем пример (используя sys.puts из node.js):

var external;
function foo() {
    external = Math.random() * 1000;
}
foo();

sys.puts(external);

Чтобы избавиться от глобальных побочных эффектов, мы можем заключить его в закрытие:

(function() {
    var external;
    function foo() {
        external = Math.random() * 1000;
    }
    foo();

    sys.puts(external);
})();

Обратите внимание, что на самом деле мы ничего не можем сделать с external или foo за пределами области действия. Они полностью закутаны в собственное закрытие, неприкасаемые.

Теперь, чтобы избавиться от побочного эффекта external:

(function() {
    function foo() {
        return Math.random() * 1000;
    }

    sys.puts(foo());
})();

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

Я также хочу отметить, что смешивать функциональное программирование с объектами - это прекрасно. Возьмем, к примеру, следующее:

var Square = function(x, y, w, h) {
   this.x = x;
   this.y = y;
   this.w = w;
   this.h = h;
};

function getArea(square) {
    return square.w * square.h;
}

function sum(values) {
    var total = 0;

    values.forEach(function(value) {
        total += value;
    });

    return total;
}

sys.puts(sum([new Square(0, 0, 10, 10), new Square(5, 2, 30, 50), new Square(100, 40, 20, 19)].map(function(square) {
    return getArea(square);
})));

Как видите, использование объектов на функциональном языке может быть прекрасным. В некоторых Лиспах даже есть так называемые списки свойств, которые можно рассматривать как объекты.

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

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

Вы должны понимать, что функциональное программирование и объектно-ориентированное программирование в некоторой степени противоположны друг другу. Невозможно одновременно быть чисто функциональным и чисто объектно-ориентированным.

Функциональное программирование - это вычисления без сохранения состояния. Объектно-ориентированное программирование - это все о переходах между состояниями. (Парафазирование this. Надеюсь, не так уж плохо)

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

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

Я стараюсь придерживаться следующих правил:

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

Следуя этим правилам, можно получить ряд преимуществ:

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

2. Надежность кода. О правильности кода легче рассуждать, если он менее сложен.

3. Функции легче тестировать, когда они делают только одно. Таким образом, будет меньше особых случаев для тестирования.

Обновлять:

Включено предложение из комментария.

Обновление 2:

Добавлены полезные ссылки.

Я думаю, что http://documentcloud.github.com/underscore/ лучше всего подходит для вам нужно - он предоставляет наиболее важные функции высшего порядка для функционального программирования и не имеет клиентских функций для манипулирования DOM, которые вам не нужны на стороне сервера. Хотя опыта у меня нет.

В качестве побочного примечания: IMHO основная особенность функционального программирования - это ссылочная прозрачность функции - результат функции зависит только от своих параметров - функция не зависит от изменений на других объектах и ​​не вносит никаких изменений, кроме своего значения результата. Это позволяет легко рассуждать о правильности программы и очень ценно для реализации предсказуемой многопоточности (если применимо). Хотя JavaScript не лучший язык программирования для FP, я ожидаю, что использование неизменяемых структур данных будет очень дорогостоящим с точки зрения производительности.

Итак, две вещи, на которые стоит обратить внимание:

1. В вашем первом примере ваша переменная не будет просачиваться в глобальную область, и именно так это должно быть сделано, попробуйте никогда не использовать переменные без их объявления, т.е. test = 'data' приведет к утечке данных в глобальную область.

2. Ваш второй пример также верен, bar1 и bar2 будут объявлены только в объекте Foo.

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

Если вам нужна среда для разработки приложений, обратите внимание на ExtJs. Лично я считаю, что это идеально вписалось бы в модель, против которой вы пытаетесь развиваться. Просто помните, как работает их модель лицензирования, прежде чем в нее вкладываться.