Qual è la differenza tra dichiarativa e di programmazione imperativo?[chiuso]

StackOverflow https://stackoverflow.com/questions/1784664

Domanda

Ho cercato il web alla ricerca di una definizione per dichiarativa e di programmazione imperativo che vorresti fare luce per me.Tuttavia, il linguaggio utilizzato in alcune delle risorse che ho trovato è tremenda, per esempio a Wikipedia.Qualcuno ha un esempio del mondo reale che avrebbero potuto mostrare di me che potrebbe portare un po ' di prospettiva su questo argomento (forse in C#)?

È stato utile?

Soluzione

Un grande C # esempio di dichiarativa vs. programmazione imperativa è LINQ.

imperativo di programmazione, vi dico la compilatore ciò che si vuole che accada, passo dopo passo.

Per esempio, cominciamo con questa collezione, e scegliere i numeri dispari: 

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

Con la programmazione imperativa, avremmo passo attraverso questo, e decidiamo che cosa vogliamo: 

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

Qui, stiamo dicendo:

  1. Creare una raccolta risultato
  2. Passo attraverso ogni numero della collezione
  3. Controllare il numero, se è strano, inserirlo i risultati

dichiarativa di programmazione, d'altra parte, si scrive codice che descrive ciò che si vuole, ma non necessariamente come ottenerlo (dichiarare i risultati desiderati, ma non il passo-passo) : 

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

Qui, stiamo dicendo "Dacci tutto dove è strano", non "Step attraverso la raccolta. Controllare questo articolo, se è strano, inserirlo in una raccolta risultato".

In molti casi, il codice sarà un misto di entrambi i modelli, anche, in modo non è sempre in bianco e nero.

Altri suggerimenti

Programmazione dichiarativa è quando si dice cosa che si desidera, e il linguaggio imperativo è quando si dice come per ottenere quello che vuoi.

Un semplice esempio in 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)

Il primo esempio è dichiarativa perché non specifica alcun "dettagli di implementazione" della costruzione della lista.

Per legare in un C # esempio, in generale, utilizzando i risultati LINQ in uno stile dichiarativo, perché non stai dicendo come per ottenere ciò che si vuole; si sta solo dicendo cosa si desidera. Si potrebbe dire lo stesso di SQL.

Uno dei vantaggi di programmazione dichiarativa è che permette al compilatore di prendere decisioni che potrebbero comportare il codice meglio di quello che si potrebbe fare a mano. Esecuzione con l'esempio SQL, se si ha una query come 

SELECT score FROM games WHERE id < 100;

SQL "compilatore" può "ottimizzare" la query perché sa che id è un campo indicizzato - o forse non è indicizzato, nel qual caso dovrà scorrere i intero set di dati in ogni caso. O forse il motore SQL sa che questo è il momento perfetto per utilizzare tutte le 8 core per una rapida ricerca parallela. , come programmatore, non sono interessati a una qualsiasi di queste condizioni, e non si deve scrivere il codice per gestire qualsiasi caso speciale in quel modo.

dichiarativa vs. imperativo

Un programmazione paradigma è uno stile fondamentale di programmazione di computer. Ci sono quattro paradigmi principali: imperativo, dichiarativa, funzionale (che è considerato un sottoinsieme del paradigma dichiarativa) e orientato agli oggetti

.

programmazione dichiarativa : è un paradigma di programmazione che esprime la logica di una computazione (Nei do) senza descrivere il flusso di controllo (Come faccio). Alcuni esempi ben noti di linguaggi specifici di dominio (dichiarativa di DSL) includono CSS, le espressioni regolari, e un sottoinsieme di SQL (query di selezione, per esempio) Molti linguaggi di markup come HTML, MXML, XAML, XSLT ... sono spesso dichiarativa. La programmazione dichiarativa cercare di confondere la distinzione tra un programma come un insieme di istruzioni e un programma come un'affermazione circa la risposta desiderata.

imperativo programmazione: è un paradigma di programmazione che descrive computazione in termini di istruzioni che cambiano stato programma. I programmi possono essere visualizzati dichiarativa doppiamente come comandi di programmazione o asserzioni matematiche.

programmazione funzionale: è un paradigma di programmazione che tratta calcolo come la valutazione delle funzioni matematiche ed evita dati di stato e mutevoli. Sottolinea l'applicazione di funzioni, in contrasto con lo stile di programmazione imperativa, che sottolinea i cambiamenti nello stato. In un linguaggio funzionale puro, come Haskell, tutte le funzioni sono senza effetti collaterali, e cambiamenti di stato sono rappresentati soltanto come funzioni che trasformano lo stato.

Il seguente esempio di programmazione imperativa in MSDN , loop attraverso i numeri da 1 a 10, e trova numeri pari. 

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);

Entrambi gli esempi producono lo stesso risultato, e uno è né migliore né peggiore rispetto agli altri. Il primo esempio richiede più codice, ma il codice è verificabile, e l'approccio imperativo ti dà il pieno controllo sui dettagli di implementazione. Nel secondo esempio, il codice è probabilmente più leggibile; tuttavia, LINQ non ti dà il controllo su ciò che accade dietro le quinte. Devi fidarti che LINQ fornirà il risultato richiesto.

Io aggiungo un altro esempio che raramente appare in dichiarativa/programmazione imperativa discussione:l'Interfaccia Utente!

In C#, è possibile creare un'interfaccia utente utilizzando diverse tecnologie.

Sull'imperativo fine, si potrebbe utilizzare DirectX o OpenGL per molto imperativamente disegnare i pulsanti, caselle di controllo, ecc...riga per riga (o, triangolo, triangolo).Spetta a voi dire come disegnare l'interfaccia utente.

Al dichiarativa fine, si dispone di WPF.Che, fondamentalmente, a scrivere un po ' di XML (yeah, yeah, yeah "XAML" tecnicamente) e il quadro fa il lavoro per voi.Si dice che l'interfaccia utente sembra.È il sistema per capire come fare.

Comunque, solo un'altra cosa a cui pensare.Solo perché una lingua è dichiarativa o imperativo non significa che non abbia certe caratteristiche dell'altro.

Inoltre, uno dei vantaggi della programmazione dichiarativa è che lo scopo è di solito più facilmente comprensibile dalla lettura di un codice, mentre imperativo ti dà un maggiore controllo sull'esecuzione.

Il succo di tutto:

Dichiarativa -> what si vuole fare

Imperativo -> how vuoi fare

Tutti sopra le risposte e gli altri posti in linea menzione seguente:

  • dichiarativa di programmazione, si scrive codice che descrive ciò che si vuole, ma non necessariamente come ottenerlo
  • si dovrebbe preferire la programmazione dichiarativa sopra la programmazione imperativa

Quello che non hanno detto a noi è come raggiungerlo . Per parte del programma per essere più dichiarativo, altre parti deve fornire l'astrazione per nascondere i dettagli di implementazione (che sono imperativi codici).

  • per es., LINQ è più dichiarativo di loop (per, mentre, ecc), per esempio, è possibile utilizzare list.Where() per ottenere un nuovo elenco filtrato. Per far funzionare tutto questo, Microsoft ha fatto tutto il lavoro pesante dietro l'astrazione LINQ.

In effetti, uno dei motivi librerie di programmazione e funzionali funzionali sono più dichiarativo è perché hanno estratta via loop e creazioni lista, nascondendo tutti i dettagli di implementazione (molto probabilmente codici imperativi con loop) dietro la scena.

In qualsiasi programma, avrete sempre entrambi i codici imperativi e dichiarativi, ciò che si dovrebbe puntare per è quello di nascondere tutto imperativo i codici dietro le astrazioni, in modo che altre parti del programma possono usarli < strong> in modo dichiarativo .

Infine, anche se la programmazione funzionale e LINQ può rendere il vostro programma più dichiarativo, si può sempre rendere ancora più dichiarativo, fornendo più astrazioni. Ad esempio: 

// 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();

Mi è piaciuta una spiegazione da un corso Cambridge + i loro esempi:

  • dichiarativa - specifica cosa a che fare, non è come per farlo
    • Es .: HTML descrive quello che dovrebbe apparire su una pagina web, non come dovrebbe essere disegnato sullo schermo
  • imperativo - specificare sia cosa e come
    • int x; - che cosa (dichiarativa)
    • x=x+1; - come
  

programmazione imperativa richiede agli sviluppatori di definire passo passo come   codice deve essere eseguito. Per dare indicazioni in modo imperativo,   si dice, “Vai 1st Street, girare a sinistra in Main, guidare due blocchi,   svoltare a destra in acero, e fermarsi alla terza casa a sinistra “. Il   Versione dichiarativa potrebbe suonare qualcosa di simile: “Guidi a Sue di   . Casa”Uno dice come fare qualcosa; l'altro dice ciò che deve essere   fatto.

     

Lo stile dichiarativo ha due vantaggi rispetto lo stile imperativo:

     
      
  • Non forzare il viaggiatore di memorizzare una lunga serie di istruzioni.
    •   
  • E 'permette al viaggiatore di ottimizzare il percorso, quando possibile.
    •   

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

La differenza ha soprattutto a che fare con il livello generale di astrazione. Con dichiarativa, ad un certo punto, si è così lontano da singoli passi che il programma ha un sacco di latitudine per quanto riguarda come ottenere il vostro risultato.

Si potrebbe guardare ad ogni pezzo di istruzione come rientranti da qualche parte su un continuum:

grado di astrazione: 

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

dichiarativa Real World Esempio:

  1. Librarian, verificare me una copia di Moby Dick. (Bibliotecario, a loro discrezione sceglie il metodo migliore per eseguire la richiesta)

imperativo Real World Esempio:

  1. Andate in libreria
  2. Trova libro sistema di organizzazione (scheda Catalogo - Old school)
  3. La ricerca sull'uso di carte Cataloghi (Hai dimenticato troppo, a destra)
  4. capire come le mensole sono etichettate ed organizzate.
  5. capire come i libri sono organizzati su uno scaffale.
  6. Riferimenti incrociati posizione book dal catalogo della carta con il sistema di organizzazione per trovare detto libro.
  7. Prendere al check-out del sistema.
  8. Controlla libro.

programmazione imperativa sta dicendo il computer in modo esplicito che cosa fare, e come farlo, come fine e come specificando

C #: 

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

dichiarativa è quando dite al computer cosa fare, ma non realmente come farlo. Datalog / Prolog è la prima lingua che viene in mente a questo proposito. Fondamentalmente tutto è dichiarativa. Non si può davvero garantire ordine.

C # è un linguaggio di programmazione molto più imperativa, ma alcune caratteristiche di C # sono più dichiarativo, come LINQ 

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

La stessa cosa potrebbe essere scritta in modo imperativo: 

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

(esempio da wikipedia Linq)

  

In informatica, programmazione dichiarativa è un paradigma di programmazione che esprime la logica di una computazione senza descrivere il flusso di controllo.

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

in poche parole il linguaggio dichiarativo è più semplice perché manca la complessità del flusso di controllo (loop, se le dichiarazioni, ecc)

Un buon paragone è 'code-behind' il modello ASP.Net. Si dispone di file dichiarativi 'aspx' e poi file di codice l'imperativo 'aspx.cs'. Spesso trovo che se posso fare tutto quello che serve nella parte dichiarativa dello script molte più persone possono seguire ciò che è stato fatto.

Philip Roberts qui :

  • programmazione imperativa racconta la macchina come fare qualcosa (con conseguente ciò che si vuole che accada)
  • Programmazione dichiarativa racconta la macchina che cosa vorreste per accadere (e il computer capisce come farlo)

Due esempi:

1. Raddoppio tutti i numeri in un array

imperativamente: 

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]

dichiarativo: 

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. Sommando tutte le voci di un elenco

imperativamente 

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

dichiarativo 

var numbers = [1,2,3,4,5]

var total = numbers.reduce(function(sum, n) {
  return sum + n
});
console.log(total) //=> 15

Si noti come gli esempi imperativi implicano la creazione di una nuova variabile, mutando, e restituendo il nuovo valore (ad esempio, come fare qualcosa accada), mentre gli esempi dichiarativi eseguono su un dato di input e restituire il nuovo valore in base all'iniziale ingresso (vale a dire, quello che vogliamo che accada).

programmazione imperativa < br> Un linguaggio di programmazione che richiede disciplina di programmazione come C / C ++, Java, COBOL, FORTRAN, Perl e JavaScript. I programmatori che scrivono in queste lingue devono sviluppare un giusto ordine delle azioni al fine di risolvere il problema, sulla base di una conoscenza del trattamento e la programmazione dei dati.

Programmazione dichiarativa < br> Un linguaggio informatico che non richiede la scrittura logica di programmazione tradizionale; Gli utenti si concentrano sulla definizione di ingresso e di uscita, piuttosto che i passi di programma richiesti in un linguaggio di programmazione procedurale come C ++ o Java.

esempi di programmazione dichiarativa sono CSS, HTML, XML, XSLT, RegX.

Giusto per aggiungere un altro esempio in termini di sviluppo di applicazioni mobili. In iOS e Android che abbiamo interfaccia Costruttori, dove possiamo definire UI delle applicazioni.

L'interfaccia utente disegnata con questi costruttori sono dichiarativa nella natura, dove ci trascinare e rilasciare i componenti. Il draeing effettiva accade sotto ed eseguito dal quadro e sistema.

Ma possiamo anche trarre i suoi componenti nel codice, e che è indispensabile in natura.

Inoltre, alcuni nuovi linguaggi come angolare JS si concentra sulla progettazione di interfacce utente in modo dichiarativo e potremmo vedere un sacco di altre lingue che offrono lo stesso supporto. Come Java doesnot avere alcun buon modo dichiarativo per disegnare applicazioni desktop native in Java Swing o Java FX, ma in un prossimo futuro si potrebbe solo.

Programma dichiarativa è solo un dato per la sua un po 'più o meno "universale" imperativo implementazione / vm.

vantaggi: specificando solo un dato, in qualche formato hardcoded (e controllati), è più semplice e meno soggetto a errori di specifica variante di qualche algoritmo imperativo direttamente. alcune specifiche complesse appena cant essere scritti direttamente, solo in qualche forma DSL. migliore e freq utilizzato in strutture di dati di DSL è set e tabelle. perché non si dispone di dipendenze tra elementi / righe. e quando tu non hai le dipendenze si ha la libertà di modificare e facilità di sostegno. (Confrontare ad esempio moduli con lezioni - con moduli felici e con le classi hai fragile problema della classe base) tutti i beni di declarativeness e DSL segue immediatamente dalla benefici di che le strutture di dati (tabelle e set). Un altro vantaggio - si può cambiare realizzazione di vm linguaggio dichiarativo, se DSL è più o meno astratto (ben progettato). fare implementazione parallela, per esempio. o la porta ad altri os ecc tutte le buone interfacce modulari isolanti specifed o protocolli ti dà tale libertà e semplicità di supporto.

svantaggi: si indovina a destra. generico (e parametrizzato da DSL) imperativo implementazione / vm algoritmo può essere più lenta e / o della memoria fame di uno specifico. in alcuni casi. se che i casi sono rari - basta non pensarci più, lascia che sia lento. se si tratta di frequient - è sempre possibile estendere la vostra DSL / VM per questo caso. da qualche parte rallentare tutti gli altri casi, certo ...

P.S. Frameworks è a metà strada tra DSL e imperativo. e come tutte le soluzioni a metà strada ... che combina deficienze, non benefici. non così sicuro e non così in fretta :) guardare jack-di-tutti i mestieri Haskell - è a metà strada tra forte semplice ML e metaprog flessibili Prolog e ... Che mostro che è. si può guardare Prolog come Haskell con booleani solo funzioni / predicati. e quanto sia semplice la sua flessibilità è contro Haskell ...

Mi chiedo solo perché nessuno ha menzionato classi attributo come uno strumento di programmazione dichiarativa in C #. La risposta popolare di questa pagina ha appena parlato di LINQ come uno strumento di programmazione dichiarativa.

Secondo Wikipedia

  

linguaggi dichiarativi comuni includono quelli di linguaggi di query di database   (Ad esempio, SQL, XQuery), espressioni regolari, programmazione logica,   programmazione funzionale, e la gestione della configurazione dei sistemi.

Quindi LINQ, come una sintassi funzionale, è sicuramente un metodo dichiarativo, ma Attributo classi in C #, come tool di configurazione, sono dichiarativa troppo. Ecco un buon punto di partenza per leggere di più: rapida Panoramica di C # Attributo Programming

Dalla mia comprensione, entrambi i termini hanno radici nella filosofia, ci sono dichiarativa e imperativo tipi di conoscenza.Conoscenze sono affermazioni di verità, dichiarazioni di fatti come la matematica assiomi.Si racconta qualcosa di voi.Imperativo, o conoscenze di tipo procedurale, ti spiega passo passo come arrivare a qualcosa.Questo è ciò che la definizione di un algoritmo è essenzialmente.Se vuoi confrontare un linguaggio di programmazione con la lingua inglese.Dichiarativa frasi qualcosa di stato.Una banale esempio, ma qui si tratta di un approccio dichiarativo di visualizzazione se due numeri sono uguali alle altre, in Java:

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

Imperativo frasi in inglese, invece, dare un comando o fare qualche tipo di richiesta.La programmazione imperativa, quindi, è solo un elenco di comandi (fai questo, fai quello).Ecco un imperativo modo di mostrare se due numeri sono uguali a vicenda o non accettare l'input dell'utente, in 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);
}

Essenzialmente, conoscenze salta alcuni elementi per formare uno strato di astrazione su tali elementi.Programmazione dichiarativa fa lo stesso.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top