Quelle est la différence entre la programmation procédurale et la programmation fonctionnelle?

Un langage fonctionnel (idéalement) vous permet d'écrire une fonction mathématique, c'est à dire une fonction qui prend n arguments et retourne une valeur. Si le programme est exécuté, cette fonction est logiquement évalué en tant que de besoin.¹

Un langage procédural, d'autre part, effectue une série de séquentielle étapes. (Il y a un moyen de transformer une logique séquentielle dans une logique fonctionnelle appelée continuation passing style.)

En conséquence, d'un point de vue purement fonctionnel programme donne toujours la même valeur pour une entrée, et l'ordre d'évaluation n'est pas bien définie; ce qui signifie que les valeurs incertaines, comme la saisie de l'utilisateur ou de valeurs aléatoires sont dur de modèle purement fonctionnelle des langues.

¹ Comme tout le reste dans cette réponse, c'est une généralisation. La propriété de l'évaluation d'un calcul lorsque son résultat est nécessaire plutôt que de façon séquentielle où il est appelé est connu comme “la paresse”, et non pas tous les langages fonctionnels sont en fait universellement paresseux, ni la paresse limité à la programmation fonctionnelle. Plutôt, la description donnée ici fournit un “schéma mental” à une réflexion sur les différents styles de programmation qui ne sont pas distinctes et opposées catégories, mais plutôt fluide idées.

Je n'ai jamais vu de cette définition, donnée ailleurs, mais je pense que cela résume les différences donné ici assez bien:

Fonctionnelle programmation met l'accent sur expressions

De procédure programmation met l'accent sur états

Expressions ont des valeurs. Un programme fonctionnel est une expression qui est la valeur est une séquence d'instructions de l'ordinateur à effectuer.

États n'ont pas de valeurs et, au lieu de modifier l'état de certains conceptuel de la machine.

Dans un rôle purement fonctionnel de la langue il n'y aurait pas de déclarations, dans le sens où il n'y a aucun moyen de manipuler l'état (ils peuvent encore avoir une construction syntaxique nommé "déclaration", mais à moins qu'il manipule état, je n'appellerais pas ça une déclaration dans ce sens). Dans un but purement procédurale de la langue il n'y aurait pas d'expressions, tout serait une instruction qui manipule l'état de la machine.

Haskell serait un exemple d'un point de vue purement fonctionnel de la langue, car il n'y a aucun moyen de manipuler l'état. Code Machine serait un exemple d'un caractère purement procédural de la langue, parce que tout, dans un programme est une déclaration qui manipule l'état des registres et de la mémoire de la machine.

La confusion, c'est que la grande majorité des langages de programmation contenir les deux des expressions et instructions, vous permettant de mixer des paradigmes. Les langues peuvent être classés comme des plus fonctionnelles ou plus de procédure basée sur la façon dont beaucoup ils encouragent l'utilisation de déclarations vs expressions.

Par exemple, C serait plus fonctionnel que le COBOL en raison d'un appel de fonction est une expression, alors que l'appel d'un sous programme en COBOL est un énoncé (qui manipule l'état des variables partagées et ne retourne pas une valeur). Python serait plus fonctionnel que C parce qu'elle permet d'exprimer la logique conditionnelle comme une expression à l'aide de court-circuit d'évaluation (test && path1 || path2, par opposition à si consolidés). Schéma serait plus fonctionnel que le Python parce que tout système est une expression.

Vous pouvez toujours écrire dans un style fonctionnel dans une langue qui encourage la procédure de paradigme et vice versa. C'est juste plus difficile et/ou plus difficile à écrire dans un paradigme qui n'est pas encouragé par le langage.

Je crois que la procédure/fonctionnel/de l'objectif de la programmation, à propos de la façon d'aborder un problème.

Le premier style tout planifier dans les étapes, et résout le problème en mettant en œuvre une étape (une procédure) à la fois. D'autre part, la programmation fonctionnelle met l'accent sur le " diviser pour mieux régner approche, où le problème est divisé en sous-problème, puis chaque sous-problème est résolu (création d'une fonction pour résoudre le sous-problème) et les résultats sont combinés pour créer la réponse pour l'ensemble du problème. Enfin, l'Objectif de la programmation imiter le monde réel par la création d'un mini-monde à l'intérieur de l'ordinateur avec de nombreux objets, dont chacun a une (un peu), des caractéristiques uniques, et interagit avec les autres. À partir de ces interactions, le résultat allait émerger.

Chaque style de programmation a ses propres avantages et inconvénients. Donc, faire quelque chose comme la "pure programmation" (c'est à dire purement une question de procédure, personne ne fait cela, par la voie, qui est une sorte de bizarre ou purement fonctionnelle ou purement objective) est très difficile, si pas impossible, à l'exception de quelques problèmes élémentaires spécialement conçu pour démontrer l'avantage d'un style de programmation (par conséquent, nous appelons ceux qui aiment la pureté de la "petite bite" :D).

Puis, à partir de ces styles, nous avons des langages de programmation qui est conçu pour optimisé pour chaque style. Par exemple, l'Assemblage est tout au sujet de la procédure. Ok, la plupart des premières langues de procédure, non seulement de l'Asm, comme en C, Pascal, (et Fortran, j'ai entendu). Ensuite, nous avons toutes les fameux Java dans l'objectif de l'école (en Fait, Java et C# est aussi dans une classe appelée "axé sur l'argent", mais qui est sujet d'une autre discussion). Aussi l'objectif est de Smalltalk. Fonctionnelle de l'école, on aurait presque "fonctionnelle" (certains les considéraient comme impur) Lisp de la famille et de la ML de la famille et de nombreux "purement fonctionnelle" Haskell, Erlang, etc. Par ailleurs, il existe de nombreux langages tels que Perl, Python, Ruby.

Une chose que je n'avais pas vu vraiment de souligner ici, c'est que moderne et fonctionnel langages comme Haskell vraiment plus sur la première classe des fonctions pour le contrôle de flux explicite que la récursivité. Vous n'avez pas besoin de définir factorielle récursive en Haskell, comme on l'a fait ci-dessus. Je pense que quelque chose comme

fac n = foldr (*) 1 [1..n]

est parfaitement idiomatique de la construction, et beaucoup plus proche dans l'esprit à l'aide d'une boucle qu'à l'utilisation explicite de la récursivité.

Langues procédurales ont tendance à garder une trace de l'état (à l'aide de variables) et ont tendance à s'exécuter comme une séquence d'étapes. Purement fonctionnelle langues ne pas garder une trace de l'état, l'utilisation des valeurs inaltérables, et ont tendance à s'exécuter comme une série de dépendances. Dans de nombreux cas, l'état de la pile d'appel contiendra les informations qui serait équivalente à celle qui serait stocké dans les variables d'état dans le code de procédure.

La récursivité est un exemple classique de style fonctionnel de la programmation.

Étendre sur Konrad commentaire:

et l'ordre d'évaluation n'est pas
bien défini

Certains langages fonctionnels ont ce qu'on appelle l'Évaluation différée. Ce qui signifie qu'une fonction n'est pas exécutée jusqu'à ce que la valeur est nécessaire. Jusqu'à ce que la fonction elle-même est ce qui est passé autour de.

Les langages procéduraux sont l'étape 1 étape 2 étape 3... si à l'étape 2, vous dites ajouter 2 + 2, il le fait à droite, puis. Dans l'évaluation différée vous dirais ajouter 2 + 2, mais si le résultat n'est jamais utilisé, il ne fait jamais le plus.

Si vous en avez l'occasion, je le conseille pour obtenir une copie du Lisp/Scheme, et de faire des projets. La plupart des idées qui ont récemment devenue bandwagons ont été exprimés en Lisp il y a des décennies: la programmation fonctionnelle, les continuations (que les fermetures), la collecte des ordures, même XML.

Alors que ce serait un bon moyen d'obtenir une longueur d'avance sur tous ces courants d'idées, et un peu plus d'ailleurs, à l'instar de calcul symbolique.

Vous devez savoir ce que la programmation fonctionnelle est bon pour, et ce qui n'est pas bon pour. Il n'est pas bon pour tout. Certains problèmes sont mieux exprimés en termes d'effets secondaires, où la même question donne differet réponses selon le moment où il est demandé.

Programmation procédurale divise les séquences d'états et à la condition que les constructions en blocs distincts appelés les procédures qui sont paramétrées sur des arguments (non-fonctionnelle) des valeurs.

De la programmation fonctionnelle est la même sauf que les fonctions sont des valeurs de première classe, de sorte qu'ils peuvent être passés comme arguments à d'autres fonctions et renvoyé que les résultats des appels de fonction.

Note que la programmation fonctionnelle est une généralisation de la programmation procédurale, dans cette interprétation. Cependant, une minorité d'interpréter "programmation fonctionnelle" pour signifier effet secondaire qui est tout à fait différent, mais hors de propos, pour tous les principaux langages fonctionnels à l'exception de Haskell.

Aucune des réponses ici montrent idiomatiques de la programmation fonctionnelle. La factorielle récursive réponse est idéal pour la représentation de la récursivité de la FP, mais la majorité de code n'est pas récursive, donc je ne pense pas que la réponse est pleinement représentatif.

Disons que vous avez un des tableaux de chaînes de caractères, et chaque chaîne représente un entier tel que "5" ou "-200". Vous voulez vérifier ce tableau de chaînes de caractères à l'encontre de vos internes de cas de test (à l'Aide de comparaison des entiers). Les deux solutions sont indiqués ci-dessous

De procédure

arr_equal(a : [Int], b : [Str]) -> Bool {
    if(a.len != b.len) {
        return false;
    }

    bool ret = true;
    for( int i = 0; i < a.len /* Optimized with && ret*/; i++ ) {
        int a_int = a[i];
        int b_int = parseInt(b[i]);
        ret &= a_int == b_int;  
    }
    return ret;
}

Fonctionnelle

eq = i, j => i == j # This is usually a built-in
toInt = i => parseInt(i) # Of course, parseInt === toInt here, but this is for visualization

arr_equal(a : [Int], b : [Str]) -> Bool =
    zip(a, b.map(toInt)) # Combines into [Int, Int]
   .map(eq)
   .reduce(true, (i, j) => i && j) # Start with true, and continuously && it with each value

Tandis que pur les langages fonctionnels sont généralement à la recherche des langues (Comme le réel-monde aime libre d'effets secondaires), le monde réel et les langages procéduraux utilisera le plus simple syntaxe fonctionnelle lorsque cela est approprié.

C'est généralement mis en œuvre avec une bibliothèque externe comme Lodash, ou intégré disponible avec de nouveaux langages comme La rouille. Le levage lourd de la programmation fonctionnelle est fait avec des fonctions/concepts comme map, filter, reduce, currying, partial, les trois derniers de que vous pouvez consulter pour plus de compréhension.

Additif

Pour être utilisé à l'état sauvage, le compilateur devra normalement travailler sur la façon de convertir la version fonctionnelle dans la version procédurale à l'interne, appel de fonction de charge est trop élevée. Récursive des cas tels que la factorielle montre va utiliser des trucs comme appel tail pour supprimer O(n) l'utilisation de la mémoire. Le fait qu'il n'y a pas d'effets secondaires permet fonctionnelle compilateurs pour mettre en œuvre les && ret d'optimisation, même lorsque le .reduce est la dernière. À l'aide de Lodash en JS, évidemment, ne permettent pas de l'optimisation, c'est donc un coup à la performance (ce Qui n'est généralement pas un souci avec le développement web). Les langues, comme la Rouille, permettra d'optimiser en interne (Et qui ont des fonctions telles que try_fold pour aider && ret optimisation).