Deklaratif ve zorunlu programlama arasındaki fark nedir? [kapalı]

Web'de, benim için biraz ışık tutacak açıklayıcı ve zorunlu programlama için bir tanım aramaya çalışıyorum. Bununla birlikte, bulduğum kaynakların bazılarında kullanılan dil göz korkutucu - örneğin Wikipedia'da . Herkes bu konuya (belki de C #) biraz perspektif getirebilir bana gösterebilir gerçek dünya örneği var mı?

Bildirici ve zorunlu programlamanın harika bir C # örneği LINQ'dur.

Zorunlu programlama ile derleyiciye ne olmasını istediğinizi adım adım söylersiniz.

Örneğin, bu koleksiyonla başlayalım ve tek sayıları seçelim:

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

Zorunlu programlama ile, bunun üzerinden geçip ne istediğimize karar verirdik:

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

İşte diyoruz:

1. Sonuç koleksiyonu oluşturma
2. Koleksiyondaki her numaraya göz atın
3. Numarayı kontrol edin, eğer tuhafsa, sonuçlara ekleyin

İle bildirim programlama, diğer taraftan, istediğiniz ama ne açıklayan kod yazmak mutlaka bunu elde etmek için nasıl (istediğiniz sonuçları beyan değil adım adım):

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

Burada, "Koleksiyona adım atın. Bu öğeyi kontrol edin, tuhafsa bir sonuç koleksiyonuna ekleyin."

Çoğu durumda, kod her iki tasarımın da bir karışımı olacaktır, bu yüzden her zaman siyah beyaz değildir.

Derken Bildirimsel programlama olduğunu Ne istediğiniz ve derken zorunlu dildir nasıl istediğini elde etmek.

Python'da basit bir örnek:

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

İlk örnek, listeyi oluştururken herhangi bir "uygulama ayrıntısı" belirtmediğimiz için bildirim niteliğindedir.

Bir C # örneğinde, genellikle LINQ kullanmak bildirici bir stil ile sonuçlanır, çünkü ne istediğinizi nasıl elde edeceğinizi söylemiyorsunuz ; sadece ne istediğini söylüyorsun . Aynı şeyi SQL için de söyleyebilirsiniz.

Deklaratif programlamanın bir yararı, derleyicinin elle yapabileceğinizden daha iyi kodla sonuçlanabilecek kararlar almasına izin vermesidir. SQL örneğiyle çalıştırma,

SELECT score FROM games WHERE id < 100;

SQL "derleyicisi" iddizin oluşturulmuş bir alan olduğunu bildiğinden bu sorguyu "en iyi duruma getirebilir" - veya belki de dizinlenmemiş olabilir, bu durumda yine de tüm veri kümesi üzerinde yineleme yapmak zorunda kalacaktır. Ya da belki SQL motoru, hızlı bir paralel arama için 8 çekirdeğin tamamını kullanmak için mükemmel bir zaman olduğunu biliyor. Sen , bir programcı olarak, bu durumlardan herhangi ilgilenen değildir ve bu şekilde herhangi bir özel durum işlemek için kod yazmak zorunda değilsiniz.

Beyan Edici ve Zorunlu

Bir programlama paradigması bilgisayar programlama temel bir tarzıdır. Dört ana paradigma vardır: zorunlu, bildirimsel, işlevsel (bildirimsel paradigmanın bir alt kümesi olarak kabul edilir) ve nesne yönelimli.

Deklaratif programlama : bir hesaplamanın mantığını (Ne yapar) kontrol akışını (Nasıl yapılır) açıklamadan ifade eden bir programlama paradigmasıdır. Etki alanına özgü dillerin (DSL) iyi bilinen bazı örnekleri arasında CSS, normal ifadeler ve bir SQL alt kümesi (örneğin SELECT sorguları) HTML, MXML, XAML, XSLT ... gibi birçok biçimlendirme dili genellikle bildiricidir. Deklaratif programlama, bir dizi talimat olarak bir program ile istenen cevap hakkında bir iddia olarak bir program arasındaki ayrımı bulanıklaştırmaya çalışır.

Zorunlu programlama : hesaplamayı bir program durumunu değiştiren ifadeler olarak tanımlayan bir programlama paradigmasıdır. Deklaratif programlar, programlama komutları veya matematiksel iddialar olarak dually görüntülenebilir.

Fonksiyonel programlama: hesaplamayı matematiksel fonksiyonların değerlendirilmesi olarak ele alan ve durum ve değişken verileri önleyen bir programlama paradigmasıdır. Durumdaki değişiklikleri vurgulayan zorunlu programlama stilinin aksine, fonksiyonların uygulanmasını vurgular. Haskell gibi saf işlevsel bir dilde, tüm işlevlerin yan etkisi yoktur ve durum değişiklikleri yalnızca durumu dönüştüren işlevler olarak temsil edilir.

Aşağıdaki MSDN'de zorunlu programlama örneği, 1 ile 10 arasındaki sayılar arasında geçiş yapar ve çift sayılarını bulur.

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

Her iki örnek de aynı sonucu verir ve biri diğerinden daha iyi veya daha kötü değildir. İlk örnek daha fazla kod gerektirir, ancak kod test edilebilir ve zorunlu yaklaşım, uygulama ayrıntıları üzerinde tam kontrol sağlar. İkinci örnekte, kod tartışmasız daha okunabilir; ancak, LINQ size perde arkasında neler olduğu konusunda kontrol vermez. LINQ'nun istenen sonucu sağlayacağına güvenmelisiniz.

Yukarıdaki tüm yanıtlar ve diğer çevrimiçi yayınlar aşağıdakilerden bahseder:

• İle bildirim programlama, istediğiniz ama ne açıklayan kod yazmak mutlaka bunu elde etmek için nasıl
• Zorunlu programlama yerine bildirimsel programlamayı tercih etmelisiniz

Bize söylemedikleri, bunu nasıl başaracaklarıdır . Programın bir kısmının daha bildirici olması için , diğer bölümlerin uygulama ayrıntılarını ( zorunlu kodlar) gizlemek için soyutlama sağlaması gerekir .

• Örneğin, LINQ döngülerden daha açıklayıcıdır (for, while vb.), Örneğin, list.Where()yeni bir filtrelenmiş liste almak için kullanabilirsiniz . Bunun çalışması için Microsoft, LINQ soyutlamasının arkasındaki tüm ağır kaldırma işlemlerini gerçekleştirdi.

Aslında, işlevsel programlama ve fonksiyonel kütüphanelerin daha bildirici olmasının nedenlerinden biri, döngülerin ve listelerin oluşturulmasını soyutlamaları, sahne arkasındaki tüm uygulama ayrıntılarını (büyük olasılıkla döngülerle zorunlu kodlar) gizlemesidir.

Herhangi bir programda, her zaman hem zorunlu hem de bildirici kodlara sahip olacaksınız, amaçlamanız gereken şey , soyutlamaların arkasındaki tüm zorunlu kodları gizlemektir , böylece programın diğer bölümleri bunları bildirici olarak kullanabilir .

Son olarak, işlevsel programlama ve LINQ programınızı daha bildirici hale getirebilse de, daha fazla soyutlama sağlayarak her zaman daha da bildirimsel hale getirebilirsiniz. Örneğin:

// 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 , bildirimsel programlamanın en uç noktası, yeni etki alanına özgü diller (DSL) icat etmektir:

1. Dize Arama : Özel zorunlu kod yerine Normal İfade
2. React.js : Doğrudan DOM manipülasyonu yerine JSX
3. AWS CloudFormation : CLI yerine YAML
4. İlişkisel Veritabanı : ISAM veya VSAM gibi eski okuma-yazma API'leri yerine SQL.

Açıklayıcı / zorunlu programlama tartışmasında nadiren ortaya çıkan başka bir örnek ekleyeceğim: Kullanıcı Arayüzü!

C # 'da, çeşitli teknolojileri kullanarak bir UI oluşturabilirsiniz.

Zorunlu sonda, düğmelerinizi, onay kutularınızı vb. Çok zorla tek tek çizmek için DirectX veya OpenGL kullanabilirsiniz. Kullanıcı arayüzünün nasıl çizileceğini söylemek size kalmıştır.

Beyan sonunda, WPF var. Temelde bir miktar XML yazıyorsunuz (evet, evet, "teknik olarak" XAML ") ve çerçeve sizin için çalışıyor. Kullanıcı arayüzünün neye benzediğini söylüyorsunuz. Nasıl yapılacağını bulmak sisteme bağlıdır.

Her neyse, düşünmek için başka bir şey. Bir dilin açıklayıcı veya zorunlu olması, diğer dilin belirli özelliklerine sahip olmadığı anlamına gelmez.

Ayrıca, bildirici programlamanın bir yararı, amacın genellikle kodun okunmasıyla daha kolay anlaşılmasıdır; oysa zorunlu olan, yürütme üzerinde daha iyi kontrol sağlar.

Her şeyin özü:

Beyan -> whatYapmak İstiyorsun

Emir Kipi -> howyapılmasını istiyorsun

Bir Cambridge kursundan + açıklamalarından hoşlandım:

• Beyan - nasıl yapılacağını değil , ne yapılacağını belirtin
  • Örn: HTML, ekranda nasıl çizilmesi gerektiğini değil, bir web sayfasında nelerin görünmesi gerektiğini açıklar
• Emir - belirtmek hem neyi ve nasıl
  • int x; - ne (beyan edici)
  • x=x+1; - Nasıl

Aradaki fark çoğunlukla soyutlamanın genel seviyesi ile ilgilidir. Açıklayıcı bir şekilde, bir noktada, bireysel adımlardan o kadar uzaktasınız ki, programın sonucunuzu nasıl alacağınız konusunda çok fazla özgürlüğü vardır.

Her talimat parçasına bir süreklilik içinde bir yere düşerken bakabilirsiniz:

Soyutlama derecesi:

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

Beyan Edici Gerçek Dünya Örneği:

1. Kütüphaneci, lütfen bana Moby Dick'in bir kopyasını kontrol et. (Kütüphaneci, kendi takdirine bağlı olarak, talebi yerine getirmek için en iyi yöntemi seçer)

Zorunlu Gerçek Dünya Örneği:

1. Kütüphaneye git
2. Kitap Organizasyon Sistemini Bul (Kart Kataloğu - Eski okul)
3. Kart Kataloglarını nasıl kullanacağınızı araştırın (Sen de unuttun, doğru)
4. Rafların nasıl etiketlendiğini ve organize edildiğini öğrenin.
5. Kitapların rafta nasıl düzenlendiğini öğrenin.
6. Söz konusu kitabı bulmak için kart kataloğundan organizasyon sistemine sahip çapraz referans kitap konumu.
7. Check-out sistemine kitap alın.
8. Kitabı kontrol et.

Zorunlu programlama, geliştiricilerin kodun nasıl yürütülmesi gerektiğini adım adım tanımlamasını gerektirir. Zorunlu bir şekilde yön vermek için, “1. Caddeye gidin, sola Ana'ya dönün, iki blok sürün, sağa Maple'a dönün ve soldaki üçüncü evde durun” diyorsunuz. Deklaratif versiyon şu şekilde gelebilir: “Sue'nun evine git.” Biri bir şeyin nasıl yapılacağını söylüyor; diğeri ne yapılması gerektiğini söylüyor.

Bildirici stil, zorunlu stile göre iki avantaja sahiptir:

• Yolcuyu uzun bir talimat setini ezberlemeye zorlamaz.
• Mümkün olduğunda yolcunun rotayı optimize etmesini sağlar.

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

Zorunlu programlama, bilgisayara açıkça ne yapılacağını ve nasıl yapılacağını, örneğin sipariş ve benzeri gibi

C #:

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

Bildirici, bilgisayara ne yapacağını söylediğinizde, ancak gerçekten nasıl yapılacağını söylemediğiniz zamandır. Datalog / Prolog bu konuda akla ilk gelen dildir. Temelde her şey açıklayıcıdır. Gerçekten sipariş garantisi veremezsiniz.

C # çok daha zorunlu bir programlama dilidir, ancak bazı C # özellikleri Linq gibi daha bildirimseldir

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

Aynı şey zorunlu olarak da yazılabilir:

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

(wikipedia Linq'ten örnek)

Bilgisayar biliminde, deklaratif programlama, kontrol akışını açıklamadan bir hesaplamanın mantığını ifade eden bir programlama paradigmasıdır.

Gönderen http://en.wikipedia.org/wiki/Declarative_programming

Özetle, bildirim dili daha basittir çünkü kontrol akışının karmaşıklığından yoksundur (döngüler, ifadeler vb.)

İyi bir karşılaştırma ASP.Net 'arkada kod' modelidir. Bildirici '.ASPX' dosyalarınız ve ardından zorunlu 'ASPX.CS' kod dosyalarınız var. Genellikle betiğin açıklayıcı yarısında ihtiyacım olan her şeyi yapabilirsem, daha fazla insanın yapılanları takip edebileceğini görüyorum.

Philip Roberts'tan çalmak :

• Zorunlu programlama makineye nasıl bir şey yapılacağını söyler (ne olmasını istersen)
• Deklaratif programlama, makineye ne olmak istediğinizi söyler (ve bilgisayar bunu nasıl yapacağını anlar)

İki örnek:

1. Bir dizideki tüm sayıları iki katına çıkarma

imperatively:

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]

bildirimli:

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. Bir listedeki tüm öğeleri toplama

imperatively

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

bildirimli

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

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

Zorunlu örneklerin nasıl yeni bir değişken yaratmayı, onu mutasyona uğratmayı ve o yeni değeri geri döndürmeyi (yani, bir şeyin nasıl gerçekleştirileceğini) içerirken, beyan edici örnekler belirli bir girdide yürütülür ve ilk girdiye (yani, , ne olmasını istiyoruz).

Zorunlu programlama
C / C ++, Java, COBOL, FORTRAN, Perl ve JavaScript gibi programlama disiplini gerektiren bir programlama dili. Bu dillerde yazılan programcılar, veri işleme ve programlama bilgisine dayanarak sorunu çözmek için uygun bir eylem sırası geliştirmelidir.

Deklaratif programlama
Geleneksel programlama mantığı yazmayı gerektirmeyen bir bilgisayar dili; Kullanıcılar, C ++ veya Java gibi bir yordamsal programlama dilinde gereken program adımları yerine girdi ve çıktıları tanımlamaya odaklanır.

Deklaratif programlama örnekleri CSS, HTML, XML, XSLT, RegX'dir.

Deklaratif program, az ya da çok "evrensel" zorunlu uygulanması / vm için bir veridir.

artılar: bazı verileri yalnızca bazı sabit kodlanmış (ve işaretli) biçimde belirtmek, bazı zorunlu algoritma varyantlarını doğrudan belirtmekten daha basit ve daha az hataya açıktır. bazı karmaşık özellikler sadece doğrudan, bazı DSL formlarında yazılamaz. DSLs veri yapılarında kullanılan en iyi ve sıklık kümeler ve tablolardır. çünkü öğeler / satırlar arasında bağımlılıklarınız yok. ve bağımlılıkları ortadan kaldırdığınızda, değiştirme ve destekleme özgürlüğüne sahip olursunuz. (örneğin, modülleri sınıflarla karşılaştırın - mutlu olduğunuz modüller ve sınıflarla kırılgan taban sınıf probleminiz vardır) tüm beyan edilebilirlik ürünleri ve DSL, bu veri yapılarının (tablolar ve kümeler) faydalarından hemen sonra gelir. başka bir artı - DSL az ya da çok soyutsa (iyi tasarlanmış) bildirim dili vm'nin uygulamasını değiştirebilirsiniz. örneğin paralel uygulama yapabilir.

eksileri: doğru tahmin. jenerik (ve DSL tarafından parametreleştirilmiş) zorunlu algoritma / vm uygulaması, belirli olandan daha yavaş ve / veya aç olabilir. bazı durumlarda. Bu durumlar nadirse - sadece unutun, yavaş olmasına izin verin. eğer sık ​​sık - bu durumda DSL / vm'nizi her zaman uzatabilirsiniz. diğer tüm vakaları yavaşlatan bir yer ...

PS Frameworks, DSL ile zorunlu olanın ortasındadır. ve tüm yarı çözümlerde olduğu gibi ... faydaları değil eksiklikleri birleştiriyorlar. o kadar güvenli değiller ve o kadar hızlı değiller :) tüm esnaf jack haskell bakmak - güçlü basit ML ve esnek metaprog Prolog ve ... ne bir canavar arasında. Prolog'a yalnızca boole işlevlerine / tahminlerine sahip bir Haskell olarak bakabilirsiniz. ve Haskell'e karşı esnekliği ne kadar basit ...

Sadece neden kimse C # bir bildirim programlama aracı olarak Attribute sınıfları söylemedi merak ediyorum. Bu sayfanın popüler yanıtı, bildirimsel bir programlama aracı olarak LINQ hakkında konuştu.

Wikipedia'ya göre

Yaygın bildirici diller arasında veritabanı sorgu dilleri (ör. SQL, XQuery), düzenli ifadeler, mantık programlama, fonksiyonel programlama ve yapılandırma yönetim sistemleri bulunur.

Dolayısıyla, işlevsel bir sözdizimi olarak LINQ kesinlikle bildirimsel bir yöntemdir, ancak bir yapılandırma aracı olarak C # 'daki Öznitelik sınıfları da bildiricidir. İşte daha fazla okumak için iyi bir başlangıç ​​noktası: C # Özellik Programlamaya Hızlı Genel Bakış

Mobil uygulama geliştirme açısından başka bir örnek daha eklemek için. İOS ve Android'de, uygulamaların kullanıcı arayüzünü tanımlayabileceğimiz Arayüz Oluşturucularımız var.

Bu Builders kullanılarak çizilen kullanıcı arayüzü, bileşenleri sürükleyip bıraktığımız niteliktedir. Gerçek çizim, çerçeve ve sistem altında gerçekleşir ve gerçekleştirilir.

Ancak tüm bileşenleri kod halinde de çizebiliriz ve bu doğada zorunludur.

Ayrıca, Angular JS gibi bazı yeni diller, kullanıcı arayüzlerini bildirici olarak tasarlamaya odaklanıyor ve aynı desteği sunan başka birçok dil görebiliriz. Java'nın yerel masaüstü uygulamalarını Java swing veya Java FX'de çizmek için iyi bir bildirim yolu yok, ancak yakın gelecekte de olabilir.

Anladığım kadarıyla, her iki terimin de felsefede kökleri vardır, açıklayıcı ve zorunlu bilgi türleri vardır. Deklaratif bilgi gerçeğin iddiaları, matematik aksiyomları gibi gerçek ifadeleridir. Size bir şey söylüyor. Zorunlu veya prosedürel bilgi, size bir şeye nasıl ulaşacağınızı adım adım anlatır. Bir algoritmanın tanımı esasen budur. İsterseniz, bilgisayar programlama dilini İngilizce ile karşılaştırın. Deklaratif cümleler bir şey ifade eder. Sıkıcı bir örnek, ancak Java'da iki sayının birbirine eşit olup olmadığını göstermenin açıklayıcı bir yolu:

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

Diğer yandan, İngilizce'deki zorunlu cümleler bir emir verir veya bir tür talepte bulunur. O halde zorunlu programlama sadece bir komut listesidir (bunu yapın, yapın). Java'da kullanıcı girişini kabul ederken iki sayının birbirine eşit olup olmadığını göstermenin zorunlu bir yolu:

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

Esasen, deklaratif bilgi, bu unsurlar üzerinde bir soyutlama katmanı oluşturmak için belirli unsurların üzerinden atlar . Deklaratif programlama da aynı şeyi yapar.