Функциональное программирование это: Что такое функциональное программирование? / Хабр

Концепции функционального программирования в F # — F#

• Статья
• 06/08/2023

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

• функции как основные используемые конструкции;
• выражения вместо инструкций;
• неизменяемые значения имеют приоритет перед переменными;
• декларативное программирование имеет приоритет перед императивным программированием.

В этой серии вы ознакомитесь с основными понятиями и особенностями функционального программирования на F#. Кроме того, в процессе вы немного научитесь писать код на F#.

Терминология

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

• Функция — это конструкция, которая возвращает выходные данные при наличии входных данных. Фактически она сопоставляет элемент из одного набора с другим набором. На практике такой подход может реализоваться разными способами, особенно при использовании функций, которые работают с коллекциями данных. Это самое простое (и важное) понятие в функциональном программировании.
• Выражение — это конструкция в коде, которая возвращает значение. В F# это значение должно быть привязано или явно игнорироваться. Выражение можно легко заменить вызовом функции.
• Чистота — это свойство функции, которое означает, что возвращаемое значение всегда будет одним и тем же при использовании одних и тех же аргументов, а ее выполнение не имеет побочных эффектов. Чистая функция полностью зависит от своих аргументов.
• Ссылочная прозрачность  — это свойство выражений, которое означает, что их можно заменить выходными данными без изменения поведения программы.
• Неизменяемость — означает, что значение нельзя изменить на месте. Но переменные можно изменить на месте.

Примеры

Все эти основные понятия демонстрируются в приведенных ниже примерах.

Функции

Самая распространенная и основная конструкция функционального программирования — это функция. Ниже приведена простая функция, которая добавляет 1 к целому числу:

let addOne x = x + 1

Ее сигнатура типа имеет следующий вид:

val addOne: x:int -> int

Сигнатуру можно прочитать как «addOne принимает значение типа int с именем x и возвращает значение типа

int«. Фактически addOne — это сопоставление значения из набора целых чисел с набором целых чисел. Такое сопоставление обозначено маркером ->. В F# вы можете просмотреть сигнатуру функции, чтобы узнать ее назначение.

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

int , определяет, как вы будете на самом деле использовать эту функцию. Кроме того, если эта функция используется правильно (с учетом сигнатуры типа), диагностику проблем можно выполнить только в теле функции addOne. Это и обуславливает особенности типизированного функционального программирования.

Выражения

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

Давайте рассмотрим предыдущую функцию, addOne. Тело функции addOne — это выражение:

// 'x + 1' is an expression!
let addOne x = x + 1

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

let addOne x = x.ToString() + "1"

Сигнатура функции теперь выглядит следующим образом:

val addOne: x:'a -> string

Так как для любого типа в F# можно вызвать ToString(), тип x изменен на универсальный (с помощью автоматического обобщения), а результирующий тип — это string.

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

if:

// Checks if 'x' is odd by using the mod operator
let isOdd x = x % 2 <> 0
let addOneIfOdd input =
    let result =
        if isOdd input then
            input + 1
        else
            input
    result

Выражение if возвращает значение с именем result. Обратите внимание, что result можно полностью опустить, сделав выражение if телом функции addOneIfOdd

. Главное, о чем нужно помнить при использовании выражений, это то, что они возвращают значение.

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

let printString (str: string) =
    printfn $"String is: {str}"

Сигнатура выглядит следующим образом:

val printString: str:string -> unit

Тип unit указывает, что значение не возвращается. Это полезно, если у вас есть подпрограммы, которые должны выполнять действия, но при этом без возврата результата.

Такой подход сильно отличается от подхода императивного программирования, где эквивалентная конструкция

if является инструкцией, а возврат значений часто осуществляется с помощью изменения переменных. Например, в C# код можно написать следующим образом:

bool IsOdd(int x) => x % 2 != 0;
int AddOneIfOdd(int input)
{
    var result = input;
    if (IsOdd(input))
    {
        result = input + 1;
    }
    return result;
}

Стоит отметить, что C# и другие языки в стиле C поддерживают тернарное выражение, что позволяет применять условное программирование на основе выражений.

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

Чистые функции

Как было сказано ранее, чистые функции — это функции, которые:

• всегда возвращают одно и то же значение для одних и тех же входных данных;
• не имеют побочных эффектов.

В этом контексте чистые функции удобно сравнить с математическими функциями. В математике функции зависят только от своих аргументов и не имеют побочных эффектов. В математической функции f(x) = x + 1 значение f(x) зависит только от значения x. Чистые функции в функциональном программировании ведут себя так же.

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

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

let mutable value = 1
let addOneToValue x = x + value

Очевидно, что функция addOneToValue не является чистой, так как value можно изменить в любое время на другое значение, отличное от 1. В функциональном программировании следует избегать такого подхода с зависимостью от глобального значения.

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

let addOneToValue x =
    printfn $"x is %d{x}"
    x + 1

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

Если удалить инструкцию printfn, функция станет чистой:

let addOneToValue x = x + 1

Хотя эта функция сама по себе не является лучшим вариантом, чем предыдущая версия с инструкцией

printfn, она гарантирует только возврат значения. Другие действия не выполняются. При вызове этой функции любое количество раз вы получите одинаковый результат. Многие разработчики, использующие функциональное программирование, ценят такую предсказуемость, обеспечиваемую чистотой.

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

Наконец, одно из самых основных понятий типизированного функционального программирования — это неизменяемость. В F# все значения являются неизменяемыми по умолчанию. Это означает, что их нельзя изменить без обработки, если только вы не пометите их как изменяемые.

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

Например, если добавить 1 к значению, будет создано новое значение, а не изменено существующее:

let value = 1
let secondValue = value + 1

В F# следующий код не изменяет функцию value, а выполняет проверку равенства:

let value = 1
value = value + 1 // Produces a 'bool' value!

Некоторые языки функционального программирования совершенно не поддерживают изменяемость. В F# она поддерживается, но не является поведением по умолчанию для значений.

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

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

Дальнейшие действия

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

Использование функций в F# подробно изучает функции, показывая, как их можно использовать в различных контекстах.

Дополнительные сведения

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

Функциональное и императивное программирование — LINQ to XML

• Статья
• 04/07/2023

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

Функциональное и императивное программирование

Принципы функционального программирования формулировались специально для поддержки чисто функционального подхода к решению проблем. Функциональное программирование является одной из форм декларативного программирования. В отличие от этого, большинство традиционных языков, в том числе такие языки объектно-ориентированного программирования (OOP), как C#, Visual Basic, C++ и Java, разрабатывались в основном для императивного (процедурного) программирования.

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

Характеристика	Императивный подход	Функциональный подход
Основная направленность усилий программиста	Способы выполнения (алгоритмы) задач и отслеживания изменений в их состоянии.	Требуемые данные и преобразования.
Изменения состояния	Важно!	Не существует.
Порядок выполнения	Важно!	Низкая значимость.
Управление основным потоком данных	Циклы, условия и вызовы функций (методов).	Вызовы функций, включая рекурсивные.
Основная единица обработки	Экземпляры структур или классов.	Функции как полноценные объекты и коллекции данных.

Безусловно, большинство языков программирования было разработано в целях поддержки определенных подходов к программированию, но многие языки общего назначения являются достаточно гибкими, чтобы поддерживать несколько подходов. Например, большинство языков, содержащих указатели на функции, могут использоваться для надежной поддержки функционального программирования. Кроме того, C# и Visual Basic включают явные расширения языка для поддержки функционального программирования, включая лямбда-выражения и вывод типов. Одной из форм декларативного, функционального программирования является технология LINQ.

Функциональное программирование с использованием XSLT

Многие разработчики XSLT знакомы с чисто функциональным подходом. Наиболее эффективный способ разработки таблицы стилей XSLT состоит в том, что каждый шаблон рассматривается как изолированное, составное преобразование. При этом совершенно не приходится задумываться над тем, в каком порядке должны проводиться вычисления. XSLT не допускает побочных эффектов (за исключением того, что экранирование механизмов для выполнения процедурного кода может привести к возникновению побочных эффектов, которые приводят к функциональной нечистоте). Тем не менее, хотя XSLT является эффективным инструментом, некоторые из его характеристик не являются оптимальными. Например, программные конструкции приходится представлять на языке XML, в связи с чем объем кода становится довольно большим, поэтому его сопровождение затрудняется. Кроме того, большая зависимость от рекурсии для управления потоком может привести к тому, что код будет трудно читать. Дополнительные сведения об XSLT см. в разделе Преобразования XSLT.

Тем не менее XSLT доказал свою полезность при чисто функциональном подходе для преобразования XML из одного вида в другой. Чисто функциональное программирование с помощью LINQ to XML во многом похоже на XSLT. Однако конструкции программирования, представленные LINQ to XML, C# и Visual Basic, позволяют создавать чистые функциональные преобразования, которые являются более удобочитаемыми и обслуживаемыми, чем XSLT.

Преимущества чистых функций

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

• Повышенная удобочитаемость и обслуживаемость. Это объясняется тем, что каждая функция разрабатывается для выполнения конкретных задач, определяемых аргументами. Функция не зависит от внешнего состояния.
• Упрощается разработка, основанная на ранее созданном коде. Код становится более приемлемым для оптимизации кода, поэтому легче реализовать изменения в проекте. Например, предположим, что в процессе написания сложного преобразования выясняется, что какой-то код повторяется несколько раз. Если оптимизация кода предусматривает преобразование в чистый метод, то полученный чистый метод можно вызывать в любое время, не беспокоясь о побочных эффектах.
• Упрощаются тестирование и отладка. Чистые функции проще тестировать отдельно от основной части кода, поэтому можно написать проверочный код, в котором чистая функция вызывается с типичными значениями, допустимыми краевыми значениями и недопустимыми краевыми значениями.

Переход для разработчиков ООП

Традиционное объектно-ориентированное программирование (OOP) является таковым, что большинство разработчиков привыкает писать код в императивном (процедурном) стиле. Переходя к разработке в чисто функциональном стиле, они должны изменить свое мышление и подход к разработке.

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

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

К счастью, для C# и Visual Basic не требуется полный переход к функциональному программированию, так как они поддерживают как императивные, так и функциональные подходы к программированию. Разработчик может сам выбирать нужный подход в зависимости от конкретного сценария. В действительности в программах часто сочетаются оба стиля.

См. также

• Введение в чистые функциональные преобразования
• Преобразования XSLT
• Рефакторинг в чистые функции

Почему разработчики влюбляются в функциональное программирование | Ари Джоури, доктор философии

От Python к Haskell, тенденция не исчезнет в ближайшее время 05

Функциональное программирование существует уже последние 60 лет, но до сих пор это всегда было нишевым явлением. Хотя такие революционеры, как Google, полагаются на свои ключевые концепции, современный программист почти ничего об этом не знает.

Это скоро изменится. Такие языки, как Java или Python, не только перенимают все больше и больше концепций функционального программирования. Новые языки, такие как Haskell, становятся полностью функциональными.

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

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

Функциональное программирование на подъеме

Существует тенденция к более функциональному стилю в языках программирования. Что это значит и где мы находимся на этом пути?

medium.com

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

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

 def square(x): 
 return x*x 

Эта функция тупая и простая; он принимает одну переменную x , предположительно int , или, возможно, float или double , и выдает квадрат этого числа.

Теперь рассмотрим эту функцию:

 global_list = []def append_to_list(x): 
 global_list.append(x) 

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

Функция не работала бы, если бы global_list не был определен заранее, а ее вывод — тот же список, хотя и измененный. Несмотря на то, что global_list никогда не объявлялся как ввод, он меняется, когда мы используем функцию:

 append_to_list(1) 
 append_to_list(2) 
 global_list 

Вместо пустого списка возвращает [1,2] . Это показывает, что список действительно является входом функции, даже если мы не указали это явно. И это может быть проблемой.

Нечестность в отношении функций

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

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

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

 newlist = []def append_to_list2(x, some_list): 
 some_list.append(x)append_to_list2(1,newlist) 
 append_to_list2(2,newlist) 
 newlist 

На самом деле мы мало что изменили . Выход по-прежнему [1,2] , а все остальное тоже осталось прежним.

Однако мы изменили одну вещь: код теперь свободен от побочных эффектов. И это отличная новость.

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

Поддержание чистоты ваших функций означает их удобство обслуживания. Фото Кристины @ wocintechchat.com на Unsplash

Функциональное программирование — это написание чистых функций

Функция с четко объявленными входами и выходами не имеет побочных эффектов. А функция без побочных эффектов — это чистая функция.

Очень простое определение функционального программирования таково: написание программы только из чистых функций. Чистые функции никогда не изменяют переменные, а только создают новые на выходе. (Я немного схитрил в приведенном выше примере: он идет по пути функционального программирования, но все еще использует глобальный список. Вы можете найти примеры получше, но здесь речь шла об основном принципе.)

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

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

Карта и уменьшить

В функциональном программировании нет циклов. Рассмотрим эти циклы Python:

 целых числа = [1,2,3,4,5,6] 
 нечетных_целых = [] 
 квадратных_нечетных = [] 
 всего = 0 для i в целых числах: 
, если i%2 == 1 
 нечетных_целых .append(i)для i в нечетных_целых: 
 в квадрате.append(i*i)для i в квадратных_нечетных: 
 итого += i 

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

Вместо этого рассмотрим следующее:

 from functools import reduceintegers = [1,2,3,4,5,6] 
 odd_ints = filter(lambda n: n % 2 == 1, integers) 
 squared_odds = map(lambda n: n * n, нечетные_целые) 
 итого = уменьшить (лямбда-акк, n: акк + n, квадрат_нечетных) 

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

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

Лямбда-функции

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

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

Статическая типизация

Приведенный выше пример не имеет статической типизации. При этом он функционален.

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

Функциональное программирование на одних языках проще, чем на других. Фото Кристины @ wocintechchat.com на Unsplash

Perl

Perl использует совершенно иной подход к побочным эффектам, чем большинство языков программирования. Он включает магический аргумент $_ , что делает побочные эффекты одной из его основных функций. У Perl есть свои достоинства, но я бы не стал пробовать на нем функциональное программирование.

Java

Желаю вам удачи в написании функционального кода на Java. Мало того, что половина вашей программы будет состоять из статических ключевых слов; большинство других Java-разработчиков также назовут вашу программу позором.

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

Scala

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

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

Что такое функциональное программирование?

расшифровка, казалось бы, сложной концепции

medium.com

Python

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

Clojure

По словам его создателя, Clojure примерно на 80% функционален. Все значения неизменяемы по умолчанию, точно так же, как они нужны вам в функциональном программировании. Однако вы можете обойти это, используя оболочки изменяемых значений вокруг этих неизменяемых значений. Когда вы открываете такую ​​обертку, вещь, которую вы получаете, снова неизменна.

Haskell

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

Это еще не начало эры больших данных. Фото Остина Дистела на Unsplash

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

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

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

Спасибо за внимание! Если вы хотите узнать, как реализовать больше элементов функционального программирования в коде Python, следите за обновлениями. Я расскажу об этом в своем следующем рассказе.

Функциональное программирование VS объектно-ориентированное программирование (ООП) Что лучше….? | Шайста Фатима

5 минут чтения

·

9 июля 2019 г.

Прочитав жаргон данных, доступных в Интернете, можно так и не найти причину использовать функциональное программирование вместо объектно-ориентированного программирования или наоборот! Ответ таков: это скорее личное предпочтение, чем вопрос о том, что лучше другого? Давайте погрузимся в оба, чтобы сделать собственный выбор!

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

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

Например, , если вы вызываете функцию getSum(), она вычисляет сумму двух входных данных и возвращает сумму. Учитывая одинаковые входные данные для x и y, мы всегда будем получать один и тот же результат для суммы.

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

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

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

Например, , у нас может быть Объект Person , который представляет все данные о человеке: вес, рост, цвет кожи, цвет волос, длину волос и т. д. Это будут атрибуты. Тогда у объекта-человека также будет вещей, которые он может делать , например: поднять коробку, положить коробку, поесть, поспать и т. д. Это будут функции, которые обрабатывают данные, хранящиеся в объекте.

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

Лучшее сравнение функционального и объектного программирования

Минусы функционального программирования…. действительно требуется другое мышление, чтобы подойти к вашему коду с функциональной точки зрения. Легко мыслить объектно-ориентированными терминами, потому что это похоже на то, как моделируемый объект происходит в реальном мире. Функциональное программирование — это работа с данными. Преобразование сценария реального мира в просто данные может потребовать дополнительных размышлений.

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

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

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

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

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

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

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

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

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

Ссылки:

Функциональное программирование или ООП — какой из них полезнее

Функциональное программирование — это метод программирования, который делает упор на оценку функций и разработку…

www.educba.com

Что лучше — Функциональное программирование или объектно-ориентированное?

Возможно, вы задали неправильный вопрос

medium.