Quelle est la différence entre une programmation déclarative et impérative? [fermé]

J'ai cherché sur le Web à la recherche d'une définition de programmation déclarative et impérative qui pourrait m'éclairer. Cependant, le langage utilisé dans certaines des ressources que j'ai trouvées est intimidant - par exemple sur Wikipedia . Quelqu'un at-il un exemple concret qu'il pourrait me montrer qui pourrait apporter une certaine perspective à ce sujet (peut-être en C #)?

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

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

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

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

Avec une programmation impérative, nous franchirions cette étape et déciderions ce que nous voulons:

List<int> results = new List<int>();
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 nombre, s'il est impair, ajoutez-le aux résultats

Avec la programmation déclarative , en revanche, vous écrivez du 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 étrange", et non "Parcourez la collection. Vérifiez cet élément, s'il est étrange, ajoutez-le à une collection de résultats."

Dans de nombreux cas, le code sera également un mélange des deux modèles, il n'est donc pas toujours 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.

Pour lier un exemple C #, généralement, l'utilisation de LINQ donne un style déclaratif, car vous ne dites pas comment obtenir ce que vous voulez; vous dites seulement ce que vous voulez. On pourrait 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 qui pourraient entraîner un meilleur code que ce que vous pourriez faire à la main. 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 qu'il ids'agit d'un champ indexé - ou peut-être qu'il n'est pas indexé, auquel cas il devra de toute façon itérer sur l'ensemble des données. 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 à écrire votre code pour gérer un cas spécial de cette manière.

Déclaratif vs impératif

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

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

Programmation impérative : est un paradigme de programmation qui décrit le calcul en termes d'instructions qui changent l'état d'un 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 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 fonctionnel pur, comme Haskell, toutes les fonctions sont sans effets secondaires et les changements d'état ne sont représentés que comme des fonctions qui transforment l'état.

L'exemple suivant de programmation impérative dans MSDN , parcourt les numéros 1 à 10 et trouve les numéros pairs.

var numbersOneThroughTen = new List<int> { 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<int>();
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 donne pas le contrôle de ce qui se passe dans les coulisses. Vous devez avoir confiance que LINQ fournira le résultat demandé.

Toutes les réponses ci-dessus et autres messages en ligne mentionnent ce qui suit:

• Avec la programmation déclarative , vous écrivez du code qui décrit ce que vous voulez, mais pas nécessairement comment l'obtenir
• Vous devriez 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 d'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 fait tout le gros du travail derrière l'abstraction LINQ.

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

Dans tout programme, vous aurez toujours des codes impératifs et déclaratifs, ce que vous devriez viser est de cacher tous les codes impératifs derrière les abstractions, afin que d'autres parties du programme puissent les utiliser de manière déclarative .

Enfin, bien que la programmation fonctionnelle 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
const bestProducts = [];
for(let i = 0; i < products.length; i++) {
    let product = products[i];
    if (product.rating >= 5 && product.price < 100) {
        bestProducts.push(product);
    }
}


// More declarative
const bestProducts = products.filter(function(product) {
    return product.rating >= 5 && product.price < 100;
});

// Most declarative, implementation details are hidden in a function
const bestProducts = getBestProducts();

PS l'extrême de la programmation déclarative est d'inventer de nouveaux langages spécifiques au domaine (DSL):

1. Recherche de chaîne : expression régulière au lieu du code impératif personnalisé
2. React.js : JSX au lieu de la manipulation directe du DOM
3. AWS CloudFormation : YAML au lieu de CLI
4. Base de données relationnelle : SQL au lieu des anciennes API de lecture-écriture telles que ISAM ou VSAM.

J'ajouterai 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.

Du côté impératif, vous pouvez utiliser DirectX ou OpenGL pour dessiner très impérativement vos boutons, cases à cocher, etc ... ligne par ligne (ou vraiment, triangle par triangle). C'est à vous de dire comment dessiner l'interface utilisateur.

À la fin déclarative, vous avez WPF. Vous écrivez essentiellement 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 trouver comment le faire.

Quoi qu'il en soit, juste une autre chose à laquelle penser. Ce n'est pas parce qu'une langue est déclarative ou impérative qu'elle ne possède pas certaines caractéristiques de l'autre.

En outre, l'un des avantages de la programmation déclarative est que le but est généralement plus facile à comprendre à la lecture du code, tandis que l'impératif vous donne un contrôle plus fin de l'exécution.

L'essentiel de tout cela:

Déclaratif -> whatvous voulez faire

Impératif -> howvous voulez que ce soit fait

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

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

La différence est principalement liée au niveau global d'abstraction. Avec déclarative, à un moment donné, vous êtes tellement loin des étapes individuelles que le programme a beaucoup de latitude pour savoir comment obtenir votre résultat.

Vous pourriez considérer chaque instruction comme se situant quelque part dans un continuum:

Degré d'abstraction:

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

Exemple déclaratif du monde réel:

1. Bibliothécaire, veuillez me consulter une copie de Moby Dick. (Le bibliothécaire, à sa discrétion, choisit la meilleure méthode pour exécuter la demande)

Exemple impératif du monde réel:

1. Allez dans la bibliothèque
2. Trouver le système d'organisation du livre (Catalogue de cartes - Old school)
3. Rechercher comment utiliser les catalogues de cartes (vous avez également oublié, à droite)
4. Découvrez comment les étagères sont étiquetées et organisées.
5. Découvrez comment les livres sont organisés sur une étagère.
6. Référence croisée de l'emplacement du livre du catalogue de cartes avec le système d'organisation pour trouver ledit livre.
7. Prenez le livre au système de caisse.
8. Consultez le livre.

La programmation impérative oblige les développeurs à définir étape par étape comment le code doit être exécuté. Pour donner des directives de façon impérative, vous dites: «Allez dans la 1ère rue, 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.» La version déclarative pourrait ressembler à quelque chose comme ceci: "Conduisez à la maison de Sue." On dit comment faire quelque chose; l'autre dit ce qui doit être fait.

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

• Cela n'oblige pas le voyageur à mémoriser une longue série d'instructions.
• Il permet au voyageur d'optimiser l'itinéraire lorsque cela est possible.

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

La programmation impérative indique explicitement à l'ordinateur ce qu'il doit faire et comment le faire, comme spécifier l'ordre et autres

C #:

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

Déclaratif, c'est quand vous dites à l'ordinateur quoi faire, mais pas vraiment comment le faire. Datalog / Prolog est la première langue qui me vient à l'esprit à cet égard. Fondamentalement, tout est déclaratif. Vous ne pouvez pas vraiment garantir la commande.

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 s'écrire impérativement:

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

(exemple de wikipedia Linq)

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

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

en un mot, le langage déclaratif est plus simple car il manque la complexité du flux de contrôle (boucles, instructions if, etc.)

Une bonne comparaison est le modèle «code-behind» d'ASP.Net. 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 peuvent suivre ce qui se fait.

Voler Philip Roberts ici :

• La programmation impérative indique à la machine comment faire quelque chose (résultant en ce que vous voulez arriver)
• La programmation déclarative indique à la machine ce que vous aimeriez que cela se produise (et l'ordinateur détermine comment le faire)

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éclarativement:

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écapitulation 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éclarativement

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 la création d'une nouvelle variable, sa mutation et le retour de cette nouvelle valeur (c.-à-d., Comment faire quelque chose), tandis que les exemples déclaratifs s'exécutent sur une entrée donnée et renvoient la nouvelle valeur en fonction de l'entrée initiale (c.-à-d. , ce que nous voulons arriver).

Programmation impérative
Langage de programmation qui nécessite une discipline de programmation telle que C / C ++, Java, COBOL, FORTRAN, Perl et JavaScript. Les programmeurs écrivant dans de tels langages doivent développer un ordre approprié d'actions afin de résoudre le problème, basé sur une connaissance du traitement et de la programmation des données.

Programmation déclarative
Un langage informatique qui ne nécessite pas d'écrire la logique de programmation traditionnelle; Les utilisateurs se concentrent sur la définition de l'entrée et de la sortie plutôt que sur les étapes du programme requises 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 sa mise en œuvre impérative plus ou moins "universelle" / vm.

avantages: spécifier juste une donnée, dans un format codé en dur (et vérifié), est plus simple et moins sujet aux erreurs que de spécifier directement la variante d'un algorithme impératif. certaines spécifications complexes ne peuvent tout simplement pas être écrites directement, uniquement sous une forme DSL. Les meilleurs et les plus fréquents 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 lorsque vous n'avez pas de dépendances, vous avez la liberté de modifier et la facilité de prise en charge. (comparer par exemple des modules avec des classes - avec des modules qui vous plaisent et avec des classes où vous avez un problème de classe de base fragile) tous les biens de déclarativité et DSL découlent immédiatement des 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 implémentation parallèle, par exemple.

inconvénients: vous devinez bien. L'implémentation générique (et paramétrée par DSL) impérative d'algorithme / vm peut être plus lente et / ou plus gourmande en mémoire qu'une application spécifique. dans certains cas. si ces cas sont rares - oubliez-les, laissez-les ralentir. si c'est fréquent - vous pouvez toujours étendre votre DSL / vm pour ce cas. quelque part ralentissant tous les autres cas, bien sûr ...

Frameworks PS est à mi-chemin entre DSL et impératif. et comme toutes les solutions à mi-chemin ... elles combinent des carences, pas des bénéfices. ils ne sont pas si sûrs et pas si rapides :) regardez le haskell jack-of-all-trades - c'est à mi-chemin entre un ML simple fort et un 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 combien sa flexibilité est simple contre Haskell ...

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

Selon Wikipedia

Les langages déclaratifs courants incluent ceux des langages de requête de base de données (par exemple, SQL, XQuery), les expressions régulières, la programmation logique, la programmation fonctionnelle 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'attributs en C #, en tant qu'outil de configuration, sont également déclaratives. Voici un bon point de départ pour en savoir plus: Aperçu rapide de la programmation des attributs C #

Juste pour ajouter 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 l'interface utilisateur des applications.

L'interface utilisateur dessinée à l'aide de ces générateurs est de nature déclarative, où nous glissons-déposons les composants. Le dessin réel se produit en dessous et est exécuté par le cadre et le système.

Mais nous pouvons également dessiner tous les composants dans le code, ce qui est impératif par nature.

De plus, certains nouveaux langages comme Angular JS se concentrent sur la conception déclarative des interfaces utilisateur et nous pouvons voir beaucoup d'autres langages offrant le même support. Comme Java n'a pas de bon moyen déclaratif pour dessiner des applications de bureau natives dans Java swing ou Java FX, mais dans un proche avenir, elles pourraient le faire.

D'après ma compréhension, les deux termes ont leurs racines dans la philosophie, il existe des types déclaratifs et impératifs de connaissances. Les connaissances déclaratives sont des affirmations de vérité, des déclarations de fait comme les axiomes mathématiques. Ça vous dit quelque chose. La connaissance impérative ou procédurale vous indique étape par étape comment arriver à quelque chose. C'est essentiellement la définition d'un algorithme. 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 façon déclarative d'afficher si deux nombres sont égaux l'un à l'autre, en Java:

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

Les phrases impératives en anglais, d'autre part, donnent une commande ou font une sorte de demande. La programmation impérative n'est alors qu'une liste de commandes (faites ceci, faites cela). Voici un moyen impératif d'afficher si deux nombres sont égaux ou non lors de l'acceptation des entrées utilisateur, en Java:

private static Scanner input;    

public static void main(String[] 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);
}

Essentiellement, la connaissance déclarative saute certains éléments pour former une couche d'abstraction sur ces éléments. La programmation déclarative fait de même.