Quelle est la différence entre la programmation déclarative et impérative

J’ai cherché sur Internet à la recherche d’une définition de la programmation déclarative et impérative qui me permettrait d’éclairer un peu. Cependant, le langage utilisé dans certaines des ressources que j’ai trouvées est décourageant, par exemple sur Wikipedia . Est-ce que quelqu’un a un exemple concret qu’il pourrait me montrer qui pourrait apporter une perspective à ce sujet … peut-être en C #.

    LINQ est un excellent exemple de programmation déclarative vs impérative.

    Avec la programmation impérative , vous indiquez au compilateur ce que vous voulez, étape par étape.

    Par exemple, commençons par cette collection et choisissons les nombres impairs:

    List collection = new List { 1, 2, 3, 4, 5 }; 

    Avec la programmation impérative, nous passerions en revue tout cela et déciderions de ce que nous voulons:

     List results = new List(); foreach(var num in collection) { if (num % 2 != 0) results.Add(num); } 

    Ici, nous disons:

    1. Créer une collection de résultats
    2. Parcourez chaque numéro de la collection
    3. Vérifiez le numéro, si c’est étrange, ajoutez-le aux résultats

    En revanche, avec la programmation déclarative , vous écrivez un code qui décrit ce que vous voulez, mais pas nécessairement comment l’obtenir (déclarez les résultats souhaités, mais pas étape par étape):

     var results = collection.Where( num => num % 2 != 0); 

    Ici, nous disons “Donnez-nous tout ce qui est bizarre”, et non “Parcourez la collection. Cochez cet élément, si c’est étrange, ajoutez-le à une collection de résultats.”

    Dans de nombreux cas, le code sera également un mélange des deux conceptions, donc ce n’est pas toujours le cas en noir et blanc.

    La programmation déclarative, c’est quand vous dites ce que vous voulez, et le langage impératif, c’est quand vous dites comment obtenir ce que vous voulez.

    Un exemple simple en Python:

     # Declarative small_nums = [x for x in range(20) if x < 5] # Imperative small_nums = [] for i in range(20): if i < 5: small_nums.append(i) 

    Le premier exemple est déclaratif car nous ne spécifions aucun "détail d'implémentation" de la construction de la liste.

    Lier un exemple C #, généralement, utiliser LINQ donne un résultat déclaratif, car vous ne dites pas comment obtenir ce que vous voulez; vous ne faites que dire ce que vous voulez. Vous pourriez en dire autant de SQL.

    L’un des avantages de la programmation déclarative est qu’elle permet au compilateur de prendre des décisions susceptibles d’aboutir à un meilleur code que celui que vous pourriez avoir à la main. En cours d'exécution avec l'exemple SQL, si vous aviez une requête comme

     SELECT score FROM games WHERE id < 100; 

    le "compilateur" SQL peut "optimiser" cette requête car il sait que id est un champ indexé - ou peut-être n'est-il pas indexé, auquel cas il devra itérer l'ensemble du fichier. Ou peut-être que le moteur SQL sait que c'est le moment idéal pour utiliser les 8 cœurs pour une recherche parallèle rapide. En tant que programmeur, vous n'êtes concerné par aucune de ces conditions et vous n'avez pas besoin d'écrire votre code pour gérer un cas particulier de cette manière.

    Déclaratif vs. Impératif

    Un paradigme de programmation est un style fondamental de programmation informatique. Il existe quatre principaux paradigmes: impératif, déclaratif, fonctionnel (considéré comme un sous-ensemble du paradigme déclaratif) et orienté object.

    Programmation déclarative : est un paradigme de programmation qui exprime la logique d’un calcul (What do) sans décrire son stream de contrôle (How do). Certains exemples bien connus de langages spécifiques à un domaine déclaratif incluent les CSS, les expressions régulières et un sous-ensemble de SQL (requêtes SELECT, par exemple). De nombreux langages tels que HTML, MXML, XAML, XSLT … sont souvent déclaratifs. La programmation déclarative tente de brouiller la distinction entre un programme en tant qu’ensemble d’instructions et un programme en tant qu’affirmation sur la réponse souhaitée.

    Programmation impérative : est un paradigme de programmation qui décrit le calcul en termes d’énoncés qui modifient un état du programme. Les programmes déclaratifs peuvent être considérés comme des commandes de programmation ou des assertions mathématiques.

    Programmation fonctionnelle: est un paradigme de programmation qui traite le calcul comme l’évaluation des fonctions mathématiques et évite les données d’état et les données mutables. Il met l’accent sur l’application des fonctions, contrairement au style de programmation impératif, qui met l’accent sur les changements d’état. Dans un langage purement fonctionnel, tel que Haskell, toutes les fonctions sont sans effets secondaires et les modifications d’état ne sont représentées que comme des fonctions transformant l’état.

    L’exemple suivant de programmation impérative dans MSDN , boucle à travers les numéros 1 à 10, et trouve les nombres pairs.

     var numbersOneThroughTen = new List { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; //With imperative programming, we'd step through this, and decide what we want: var evenNumbers = new List(); foreach (var number in numbersOneThroughTen) { if (number % 2 == 0) { evenNumbers.Add(number); } } //The following code uses declarative programming to accomplish the same thing. // Here, we're saying "Give us everything where it's odd" var evenNumbers = numbersOneThroughTen.Select(number => number % 2 == 0); 

    Les deux exemples donnent le même résultat et l’un n’est ni meilleur ni pire que l’autre. Le premier exemple nécessite plus de code, mais le code est testable et l’approche impérative vous donne un contrôle total sur les détails de l’implémentation. Dans le deuxième exemple, le code est sans doute plus lisible; Cependant, LINQ ne vous permet pas de contrôler ce qui se passe en coulisse. Vous devez avoir confiance que LINQ fournira le résultat demandé.

    Je vais append un autre exemple qui apparaît rarement dans la discussion de programmation déclarative / impérative: l’interface utilisateur!

    En C #, vous pouvez créer une interface utilisateur à l’aide de différentes technologies.

    À la fin impérative, vous pouvez utiliser DirectX ou OpenGL pour dessiner très impérativement vos boutons, cases à cocher, etc … ligne par ligne (ou vraiment sortingangle par sortingangle). C’est à vous de dire comment dessiner l’interface utilisateur.

    À la fin déclarative, vous avez WPF. En gros, vous écrivez du XML (ouais, ouais, “XAML” techniquement) et le framework fait le travail pour vous. Vous dites à quoi ressemble l’interface utilisateur. C’est au système de déterminer comment le faire.

    En tout cas, juste une autre chose à penser. Le fait qu’une langue soit déclarative ou impérative ne signifie pas qu’elle n’a pas certaines caractéristiques de l’autre.

    En outre, l’un des avantages de la programmation déclarative est que l’objective est généralement plus facile à comprendre en lisant le code, alors que l’impératif vous donne un contrôle plus précis sur l’exécution.

    L’essentiel de tout cela:

    Déclaratif -> what vous voulez faire

    Impératif -> how voulez-vous?

    Toutes les réponses ci-dessus et d’autres publications en ligne mentionnent les suivantes:

    • Avec la programmation déclarative , vous écrivez du code qui décrit ce que vous voulez, mais pas nécessairement comment l’obtenir
    • Vous devez préférer la programmation déclarative à la programmation impérative

    Ce qu’ils ne nous ont pas dit, c’est comment y parvenir . Pour qu’une partie du programme soit plus déclarative, d’autres parties doivent fournir l’abstraction pour masquer les détails de l’implémentation (qui sont les codes impératifs ).

    • Par exemple, LINQ est plus déclaratif que les boucles (for, while, etc.), par exemple, vous pouvez utiliser list.Where () pour obtenir une nouvelle liste filtrée. Pour que cela fonctionne, Microsoft a mis tout en œuvre pour l’abstraction LINQ.

    En fait, l’une des raisons pour lesquelles la functional programming et les bibliothèques fonctionnelles sont plus déclaratives est qu’elles ont supprimé les boucles et les listes de créations, cachant tous les détails de l’implémentation (probablement les codes impératifs avec boucles) derrière la scène.

    Dans n’importe quel programme, vous aurez toujours des codes à la fois impératifs et déclaratifs, ce que vous devriez viser est de cacher tous les codes impératifs derrière les abstractions, de sorte que d’autres parties du programme puissent les utiliser de manière déclarative .

    Enfin, bien que la functional programming et LINQ puissent rendre votre programme plus déclaratif, vous pouvez toujours le rendre encore plus déclaratif en fournissant plus d’abstractions. Par exemple:

     // JavaScript example // Least declarative var bestProducts = []; for(var i = 0; i < products.length; i++) { var product = products[i]; if (product.rating >= 5 && product.price < 100) { bestProducts.push(product); } } // More declarative var bestProducts = products.filter(function(product) { return product.rating >= 5 && product.price < 100; }); // Most declarative, implementation details are hidden in a function var bestProducts = getBestProducts(); 

    La programmation impérative exige que les développeurs définissent pas à pas la manière dont le code doit être exécuté. Pour donner des indications impératives, vous dites: «Allez à 1st Street, tournez à gauche sur Main, conduisez deux pâtés de maisons, tournez à droite sur Maple et arrêtez-vous à la troisième maison sur la gauche. : «Conduisez chez Sue.» On dit comment faire quelque chose; l’autre dit ce qu’il faut faire.

    Le style déclaratif présente deux avantages par rapport au style impératif:

    • Cela ne force pas le voyageur à mémoriser un long jeu d’instructions.
    • Il permet au voyageur d’optimiser l’itinéraire si possible.

    Calvert, C Kulkarni, D (2009). Essentiel LINQ. Addison Wesley. 48.

    J’ai aimé une explication d’un cours de Cambridge + leurs exemples:

    • Déclaratif – précisez quoi faire, pas comment le faire
      • Par exemple: HTML décrit ce qui doit apparaître sur une page Web, pas comment il devrait être dessiné à l’écran
    • Impératif – spécifier à la fois quoi et comment
      • int x; – quoi (déclaratif)
      • x=x+1; – Comment

    La différence a principalement à voir avec le niveau global d’abstraction. Avec les déclarations, à un moment donné, vous êtes si loin des étapes individuelles que le programme a beaucoup de latitude quant à la manière d’obtenir votre résultat.


    Vous pourriez regarder chaque instruction comme tombant quelque part sur un continuum:

    Degré d’abstraction:

     Declarative <<=====|==================>> Imperative 

    Exemple concret déclaratif:

    1. Bibliothécaire, s’il vous plaît vérifiez-moi un exemplaire de Moby Dick. (Le bibliothécaire, à sa discrétion, choisit la meilleure méthode pour exécuter la demande)

    Exemple de monde réel impératif:

    1. Aller dans la bibliothèque
    2. Système d’organisation du livre (Catalogue de cartes – Ancienne école)
    3. Recherchez comment utiliser les catalogues de cartes (vous avez aussi oublié, à droite)
    4. Déterminez comment les étagères sont étiquetées et organisées.
    5. Déterminez comment les livres sont organisés sur une étagère.
    6. Emplacement du livre de référence croisée à partir du catalogue de cartes avec le système d’organisation pour trouver ledit livre.
    7. Prenez le livre au système de caisse.
    8. Découvrez le livre.

    En informatique, la programmation déclarative est un paradigme de programmation qui exprime la logique d’un calcul sans décrire son stream de contrôle.

    De http://en.wikipedia.org/wiki/Declarative_programming

    En bref, le langage déclaratif est plus simple car il ne présente pas la complexité du stream de contrôle (boucles, instructions if, etc.).

    Une bonne comparaison est le modèle ASP.Net «code-behind». Vous avez des fichiers déclaratifs “.ASPX” puis les fichiers de code impératifs “ASPX.CS”. Je trouve souvent que si je peux faire tout ce dont j’ai besoin dans la moitié déclarative du script, beaucoup plus de gens pourront suivre ce qui se passe.

    La programmation impérative consiste à dire explicitement à l’ordinateur quoi faire et comment le faire, comme spécifier l’ordre et

    C #:

     for (int i = 0; i < 10; i++) { System.Console.WriteLine("Hello World!"); } 

    Déclarer est quand vous dites à l'ordinateur quoi faire, mais pas vraiment comment le faire. Datalog / Prolog est le premier langage qui vient à l’esprit à cet égard. En gros, tout est déclaratif. Vous ne pouvez pas vraiment garantir l'ordre.

    C # est un langage de programmation beaucoup plus impératif, mais certaines fonctionnalités C # sont plus déclaratives, comme Linq

     dynamic foo = from c in someCollection let x = someValue * 2 where c.SomeProperty < x select new {c.SomeProperty, c.OtherProperty}; 

    La même chose pourrait être écrite impérativement:

     dynamic foo = SomeCollection.Where ( c => c.SomeProperty < (SomeValue * 2) ) .Select ( c => new {c.SomeProperty, c.OtherProperty} ) 

    (exemple de wikipedia Linq)

    Volant de Philip Roberts ici :

    • La programmation impérative indique à la machine comment faire quelque chose (ce qui entraîne ce que vous voulez)
    • La programmation déclarative indique à la machine ce que vous aimeriez faire (et l’ordinateur le sait)

    Deux exemples:

    1. Doubler tous les nombres d’un tableau

    Impérativement:

     var numbers = [1,2,3,4,5] var doubled = [] for(var i = 0; i < numbers.length; i++) { var newNumber = numbers[i] * 2 doubled.push(newNumber) } console.log(doubled) //=> [2,4,6,8,10] 

    Déclaratif:

     var numbers = [1,2,3,4,5] var doubled = numbers.map(function(n) { return n * 2 }) console.log(doubled) //=> [2,4,6,8,10] 

    2. Récapitulatif de tous les éléments d’une liste

    Impérativement

     var numbers = [1,2,3,4,5] var total = 0 for(var i = 0; i < numbers.length; i++) { total += numbers[i] } console.log(total) //=> 15 

    Déclaratif

     var numbers = [1,2,3,4,5] var total = numbers.reduce(function(sum, n) { return sum + n }); console.log(total) //=> 15 

    Notez comment les exemples impératifs impliquent de créer une nouvelle variable, de la modifier, et de renvoyer cette nouvelle valeur (c.-à-d. Comment faire quelque chose), alors que les exemples déclaratifs s’exécutent sur une entrée donnée et renvoient la nouvelle valeur , ce que nous voulons arriver).

    Juste pour append un autre exemple en termes de développement d’applications mobiles. Dans iOS et Android, nous avons des constructeurs d’interface, où nous pouvons définir une interface utilisateur des applications.

    L’interface utilisateur dessinée à l’aide de ces générateurs est de nature déclarative, où l’on fait glisser les composants. Le draeing réel se produit sous et exécuté par le framework et le système.

    Mais nous pouvons également dessiner l’ensemble des composants dans le code, ce qui est impératif dans la nature.

    En outre, certains nouveaux langages, tels que Angular JS, se concentrent sur la conception déclarative d’interfaces utilisateur et d’autres langages offrant le même support. Comme JAVA, il n’ya pas de manière déclarative de dessiner des applications de bureau natives en mode JAVA swing ou JAVA FX, mais dans un avenir proche.

    Programmation impérative
    Un langage de programmation qui nécessite une discipline de programmation telle que C / C ++, Java, COBOL, FORTRAN, Perl et JavaScript. Les programmeurs qui écrivent dans de telles langues doivent développer un ordre d’action approprié pour résoudre le problème, basé sur une connaissance du traitement des données et de la programmation.

    Programmation déclarative
    Un langage informatique qui ne nécessite pas d’écriture d’une logique de programmation traditionnelle; Les utilisateurs se concentrent sur la définition des entrées et des sorties plutôt que sur les étapes du programme requirejses dans un langage de programmation procédural tel que C ++ ou Java.

    Les exemples de programmation déclarative sont CSS, HTML, XML, XSLT, RegX.

    programme déclaratif est juste une donnée pour son implémentation impérative plus ou moins “universelle” / vm.

    Plus: en spécifiant simplement une donnée, dans un format codé en dur (et vérifié), c’est plus simple et moins sujet à erreur que de spécifier directement une variante d’un algorithme impératif. certaines spécifications complexes ne peuvent pas être écrites directement, seulement sous une forme DSL. best et freq utilisés dans les structures de données DSL sont les ensembles et les tables. car vous n’avez pas de dépendances entre les éléments / lignes. et quand vous n’avez pas de dépendances, vous avez la liberté de modifier et de faciliter le support. (comparez par exemple des modules avec des classes – avec des modules que vous connaissez bien et avec des classes avec un problème de classe de base fragile), tous les produits de déclaration et DSL suivent immédiatement les avantages de ces structures de données (tables et ensembles). un autre avantage – vous pouvez changer l’implémentation du langage déclaratif vm, si DSL est plus ou moins abstrait (bien conçu). faire une mise en œuvre parallèle, par exemple. ou portez-le sur d’autres systèmes, etc. Toutes les interfaces ou protocoles d’isolation modulaire bien spécifiés vous offrent une telle liberté et facilité.

    moins: vous devinez bien. La mise en œuvre de l’algorithme / vm impératif générique (et paramétré par DSL) peut être plus lente et / ou gourmande en mémoire que celle spécifique. dans certains cas. si ce cas est rare – oubliez-le, laissez-le être lent. si elle est fréquente, vous pouvez toujours étendre votre DSL / vm pour ce cas. quelque part ralentir tous les autres cas, bien sûr …

    PS Frameworks est à mi-chemin entre DSL et impératif. et comme toutes les solutions à mi-chemin … elles combinent les déficiences et non les avantages. ils ne sont pas si sûrs et pas si vite 🙂 regardez le haskell de jack-of-all-trades – c’est à mi-chemin entre le simple ML fort et le métaprog flexible Prolog et … quel monstre c’est. Vous pouvez regarder Prolog comme un Haskell avec des fonctions / prédicats booléens uniquement. et comme sa flexibilité est simple contre Haskell …

    Je me demande simplement pourquoi personne n’a mentionné les classes d’atsortingbut comme outil de programmation déclaratif en C #. La réponse populaire de cette page vient de parler de LINQ comme outil de programmation déclaratif.

    Selon Wikipedia

    Les langages déclaratifs communs incluent ceux des langages de requête de firebase database (par exemple, SQL, XQuery), les expressions régulières, la programmation logique, la functional programming et les systèmes de gestion de configuration.

    Donc, LINQ, en tant que syntaxe fonctionnelle, est définitivement une méthode déclarative, mais les classes d’atsortingbut en C #, en tant qu’outil de configuration, sont également déclaratives. Voici un bon sharepoint départ pour en savoir plus: Présentation rapide de la programmation des atsortingbuts C #

    De mon sharepoint vue, les deux termes ont des racines dans la philosophie, il existe des types de connaissances déclaratifs et impératifs. Les connaissances déclaratives sont des affirmations de la vérité, des affirmations de faits comme les axiomes mathématiques. Il vous dit quelque chose. Les connaissances impératives ou procédurales vous indiquent, étape par étape, comment arriver à quelque chose. C’est ce que la définition d’un algorithme est essentiellement. Si vous voulez, comparez un langage de programmation informatique avec la langue anglaise. Les phrases déclaratives énoncent quelque chose. Un exemple ennuyeux, mais voici une manière déclarative d’afficher si deux nombres sont égaux, en Java:

     public static void main(Ssortingng[] args) { System.out.print("4 = 4."); } 

    Les phrases impératives en anglais, par contre, donnent une commande ou font une sorte de requête. La programmation impérative, alors, est juste une liste de commandes (faites ceci, faites cela). Voici un moyen impératif d’afficher si deux nombres sont égaux ou non en acceptant une entrée utilisateur, en Java:

     private static Scanner input; public static void main(Ssortingng[] args) { input = new Scanner(System.in); System.out.println(); System.out.print("Enter an integer value for x: "); int x = input.nextInt(); System.out.print("Enter an integer value for y: "); int y = input.nextInt(); System.out.println(); System.out.printf("%d == %d? %s\n", x, y, x == y); } 

    La connaissance déclarative passe essentiellement par- dessus certains éléments pour former une couche d’abstraction par rapport à ces éléments. La programmation déclarative fait la même chose.