Hangi faydalı alternatif kontrol yapılarını biliyorsunuz? [kapalı]

Benzer soru SO'da da kapatıldı.

Bazen programlama yaparken, bazı belirli kontrol yapılarının bizim için çok yararlı olacağını, ancak programlama dilimizde doğrudan bulunmadığını görürüz.

Hangi alternatif kontrol yapılarının hesaplamayı organize etmenin yararlı bir yolu olduğunu düşünüyorsunuz?

Buradaki amaç, parçalamayı ve muhakemeyi geliştirmek için kod yapılandırması hakkında yeni düşünme yolları elde etmektir.

Şu anda kullanılamayan arzu edilen bir sözdizimi / semantik oluşturabilir veya mevcut bir programlama dilinde daha az bilinen bir kontrol yapısından bahsedebilirsiniz.

Yanıtlar, yeni bir programlama dili veya gerçek bir dili geliştirme konusunda fikir vermelidir.

Bunu beyin fırtınası olarak düşünün, bu yüzden çılgın bir fikir olduğunu düşündüğünüz bir şey yayınlayın, ancak bazı senaryoda uygulanabilir olabilir.

Bu zorunlu programlama ile ilgilidir.

Tamam, bu eğlenceli bir soru.

Ayrıca else, ilk testte durum doğru olmadığında, süre ve döngüler için bir genel olmak istiyorum :

while (condition) {
    // process
}
else {
    // condition was never true
}

Bu durumun garip bir şekilde yeniden hesaplanmasını veya bir değişkende saklanmasını önler.

Neden birkaç cevabı bir araya getirmiyorsunuz?

while (expr) {

    // Executed every iteration, unless first{} is present.
    // May be explicitly called rest{} if you like first{} to come first.

    // Blocks may return results, and consequently be used in expressions.
    return expr;

} first {

    // Executed only on the first iteration.

} pre {

    // Executed before every iteration.

} post {

    // Executed after every iteration.

} catch (oops) {

    // All blocks are implicitly try{}ed if followed by a catch{}.

} finally {

    // Executes after the block completes, regardless of exceptions.

} else {

    // Executed if the loop body or rest{} never executes.

} never {

    // Executes only when a client is present.

} drop (bad, worse), // Explicitly ignore certain exceptions.
  until (expr);      // Here, have a post-body condition, too.

Zorunlu bir dilde genişletilebilir, genelleştirilmiş bir akış kontrol yapısı sözdizimi oldukça yararlı ve eğlenceli olacaktır. Bu görününceye kadar, sanırım sadece Lisp falan kullanacağım.

Fonksiyonlar olarak kontrol yapıları.

İstediğim for, if, else, while, vb fonksiyonlar, değil özel yapılar olmak.

İstediğim return, try/exceptve gotodevamlılık gösteren türevleri olmak.

Bunun elbette belirli bir kontrol yapısı ile ilgisi yoktur ve genel olarak kontrol yapılarını, kontrol yapılarının metalarını nasıl gördüğünüzle ilgilidir.

Bağlantılı makale kesinlikle Donald Knuth'un N + 1/2 Döngüler hakkında doğru anlıyor . C / C ++ / Java ile ifade edilmiştir:

for (;;) {
  get next element;
  if (at the end) break;
  process the element;
}

Bu, bir dosyadan satır veya karakter okumak, EOF'a ulaşıp ulaşmadığınızı test etmek ve daha sonra işlemek için kullanışlıdır. for(;;)..if(..)break;Desenin benim için deyimsel olduğunu görmeye çok alışkınım . ( Okuryazar Programlama kitabında yeniden basılmış olan Knuth makalesini okumadan önce , bu "wtf?" İdi.)

Knuth şu anahtar kelimeleri önerdi loop/while/repeat:

loop:
  S;
while C:
  T;
repeat

Nerede Sve Tsıfır veya daha fazla ifade dizisi için yer tutucular ve Cbir boolean koşuludur. Bir Sifade olmasaydı, bir while döngüsü olurdu ve herhangi bir Tifade yoksa o zaman bir do döngüsü olurdu.

Bu yapının kendisi, sıfır veya daha fazla while Ccümleye izin vererek genelleştirilebilir, böylece sonsuz döngüler ve daha sonra iki kontrole ihtiyaç duyan daha nadir koşullar ifade etmek için mükemmel hale getirilebilir .

Aynı makalede Knuth, istisnaların fırlatılması / yakalanması için yerel bir versiyon olacak bir işaret mekanizması önerdi (goto kullanımına alternatif olarak).

Benim için? Java'nın desteklediği kuyruk çağrısı optimizasyonunu diliyorum, böylece herhangi bir genel kontrol yapısını gerektiği gibi ifade edebilirim .

Güncelleme: Birçok C / C ++ / Java programcısının şu durumlarda gömülü bir atama kullanarak bu sorunu aştığını belirtmeyi unuttum while:

while ((c = getc(f)) != -1) {
   T;
}

Knuth'un yapısından gelen terimler kullanılarak, bu, tek bir ifadede birleştirilebilir Sve Cbirleştirilebilir. Başkalarının görmesini istemem Bazı insanlar, yukarıda gömülü atama görmekten nefret breakiçinde for (;;)yukarıda. Ancak ne zaman Sve Cbirleştirilemedi, örneğin Sbirden fazla ifadeye sahip olduğunda , for (;;)kodu tekrar etmeden tek alternatif budur. Diğer alternatif, Skodu çoğaltmaktır :

S;
while (C) {
  T;
  S;
}

Knuth'un loop/while/repeatalternatifi çok daha iyi görünüyor.

BCPL dili, bir valueofifade dizisini tek bir ifadeye dönüştürmek için kullanılabilecek bir ifadeye sahipti :

foo(a, b, valueof {some series of statements; resultis v});

Nerede bir some series of statementsşey olabilir ve bütün olarak valueofdeğerlendirir v.

Bu, bir this()veya çağrılması için bir argüman hesaplamanız gerektiğinde Java'da kullanışlı olabilir super()(bu, daha önce hiçbir şey olmamasını gerektirir). Tabii ki, sadece ayrı bir yöntem yazabilirsiniz, ancak bağlam için birçok yerel değerden geçmeniz gerekiyorsa bu bir acı olabilir.

finalGerekli değişkenler için kullanabiliyorsanız , valueofanonim iç sınıfları kullanarak Java'da zaten yapabilirsiniz :

foo(a, b, new Object(){String valueof(){
    String v ...; some series of statements; return v;}}.valueof());

unless(condition) {
  // ...
}

ile aynı şeyi yapar:

if(!condition) {
  // ...
}

repeat {
  // ...
} until(condition)

ile aynı şeyi yapar:

do {
  // ...
} while(!condition)

Farklı bir notta, programlama dillerinde yineleyiciler için daha iyi destek görmek istiyorum. Özellikle, çift ​​olarak iki koleksiyon aşağı gitmek istediğinizde :

for (String s, Integer i : stringsSet, integersSet) {
    // use the pair (s, i)
}

Bazı dinamik diller zaten buna sahip olabilir veya kütüphaneler ve makrolar aracılığıyla kolayca destekleyebilir, ancak bunun sorunuzun ruhunda olduğunu düşünüyorum.

İki set aynı boyutta değilse, bir istisna atabilir veya elsedöngüden sonra boyutlarda bir fark olduğunu bildirmek için bir döngü olabilir .

Doğal olarak, bunu üç veya daha fazla listeye gitmek için genelleştirebilirsiniz.

Güncelleme: Tekrarlanabilirler arasında Kartezyen ürünü yapmak da yararlı olacaktır:

for (String s, Integer i : stringsSet * integersSet) {
    // use the pair (s, i), each s with each i
}

iç içe döngülerden başka bir şey değildir:

for (String s : stringsSet) {
    for (Integer i : integersSet) {
        // use the pair (s, i), each s with each i
    }
}

Burada sunduğum iki gösterim arasında, çift sayısında bir O (n) ve O (n ^ 2) farkı olduğunu, sadece tek bir karakterin değiştiğinden biraz endişeliyim.

"Dijkstra'nın Döngüsü" ("Dijkstra'nın Korumalı Döngüsü" olarak da bilinir) vardır. Bu tanımlandı Güvenlikli Command Language (GCL) . Sözdizimi ve semantik hakkında bazı bilgileri yukarıdaki 6 Tekrarlama bölümündeki Wikipedia makalesinde bulabilirsiniz : do .

Bugünlerde bu kontrol düzeneğini doğrudan destekleyen bir programlama dili biliyorum. Öyle Oberon-07 (PDF, 70 KB). Ve while ifadesi ile "Dijkstra's Loop" u destekler. Bölüm 9.6'ya bakınız. Yukarıdaki PDF'deki ifadeler ise.

WHILE m > n DO m := m – n 
ELSIF n > m DO n := n – m 
END

PS Bu benim SO cevabımın kopyası .

Yerleşik geri izlemeli simge stili ifadeler.

Python, Icon jeneratör avantajlarından çok yararlanır ve genel olarak IMO'dan daha iyi bir iş çıkarır. Prensip olarak, geri izleme sadece bir tür istisna atışıydı, ancak ifadelerin basitliği ...

x = (a / b) else c;

sıfıra bölme gibi hata durumlarını ele almak.

Icon çıldırdı - boolean döndüren karşılaştırma işleçleri yok. Karşılaştırmalar her zaman başarılı oldu veya geri izlemeyi tetikledi ve şimdi umutsuzca hatırlamaya çalıştığım başka bir anlamsal sorun vardı ... hadi, muhtemelen unutulduğundan daha fazla bastırıldığını söyleyelim.

Her zaman ifbaşka hiçbir if (condition, success-value)şeyleri olmayan bir ifadeye sahip olmaları gerektiğini düşündüm - durum yanlış döndürürse geri izleme - ve garip karşılaştırmaları bırak.

EDIT hatırlıyorum - gerçekten açık. İki argümanla karşılaştırma başarılı veya başarısız olur - döndürülecek yeni bir değer hesaplamaz. Bu yüzden başarılı olduğunda, ne yok onu dönmek? Cevap - argümanlardan biri. Ama yazarsanız a > b, geri dönmek için mantıklı argüman hangisidir - aveya b? Peki ya b < abunun yerine yazarsanız ? Ben düşünüyorum her zaman bir şey olduğu kadar his gibi yapar sağ argüman, döndü, ama yine de genellikle bana yanlış argüman gibi görünüyordu.

Bu sadece genel bir fikir ve sözdizimidir:

if (cond)
   //do something
else (cond)
   //do something
also (cond)
   //do something
else
   //do something
end

AYRICA durum daima değerlendirilir. ELSE her zamanki gibi çalışır.

Dava için de çalışır. Muhtemelen break ifadesini ortadan kaldırmanın iyi bir yoludur:

case (exp)
   also (const)
      //do something
   else (const)
      //do something
   also (const)
      //do something
   else
      //do something
end

şu şekilde okunabilir:

switch (exp)
   case (const)
      //do something
   case (const)
      //do something
      break
   case (const)
      //do something
   default
      //do something
end

Bunun okunması yararlı mı yoksa basit mi bilmiyorum ama bu bir örnek.

Devam Geçiş Tarzı akla geliyor. Ardından, elbette, Kuyruk Çağrısı Optimizasyonuna da sahip olmak istersiniz .

Sorunsuz iş parçacığı dallanma, bir işlev gibi sözdizimi vardır, ancak ayrı bir iş parçacığında yürütür ve başlangıçta kendisine geçirilmemiş verilere erişemez.

branch foo(data, to, be, processed){
    //code
    return [resulting, data]
}

Bir şube çağrıldığında hemen bir tanıtıcı döndürür.

handle=foo(here, is, some, data)

Tanıtıcı, görevin tamamlanıp tamamlanmadığını kontrol etmek için kullanılabilir.

handle.finished() //True if the execution is complete

Sonuç, yürütme tamamlanmadan önce istenirse, ana iş parçacığı yalnızca bekler.

[result, storage]=handle.result()

Bu, daha gelişmiş çok iş parçacıklı senaryoları kapsamaz, aksine birden çok çekirdeği kullanmaya başlamak için kolay erişilebilir bir yol sağlar.

if (cond)
   //do something
else (cond)
   //do something
else (cond)
   //do something
first
   //do something
then
   //do something
else (cond)
   //do something
else
   //do something
end

3 koşuldan herhangi biri doğru olarak değerlendirilirse FIRST ve THEN blokları çalışır. İLK blok koşullu bloktan önce çalışır ve THEN koşullu blok çalıştıktan sonra çalışır.

FIRST ve THEN ifadelerini izleyen ELSE koşullu veya son yazma işlemleri bu bloklardan bağımsızdır.

Şu şekilde okuyabilir:

if (cond)
   first()
   //do something
   then()
else (cond)
   first()
   //do something
   then()
else (cond)
   first()
   //do something
   then()
else (cond)
   //do something
else
   //do something
end


function first()
   //do something
return
function then()
   //do something
return

Bu işlevler sadece okunacak bir formdur. Kapsam oluşturmazlardı. Daha çok Basic'ten bir gosub / dönüş gibi.

Tartışma konusu olarak kullanışlılık ve okunabilirlik.

Bazen kendimi ilk yineleme sırasında farklı bir şey yapması gereken bir döngü yazarken buluyorum. Örneğin, <td> etiketleri yerine <th> etiketlerini görüntüleme.

Bu durumu boole bayrağıyla ele alıyorum. Bunun gibi bir şey:

first = true

while (some_condition)
    if (first)
        do_something
        first = false
    else
        do_something_else

Çoğu firstzaman yanlış olacağı zaman her yinelemenin değerini kontrol etmek aptalca görünür .

İlk yinelemede farklı bir döngü gövdesi belirtmek için bir döngü seçeneğine sahip olmak istiyorum. Ayrı bir değişkene gerek yoktur. Derlenen kod da bir taneye ihtiyaç duymaz, çünkü üretilen kodun biri ilk yineleme ve diğeri geri kalanı için olmak üzere iki gövdesi olacaktır.

[stackoverflow ile ilgili kendi cevabımdan kopyalandı]

ignoring - Belirli bir kod bloğunda meydana gelen istisnaları yok saymak.

try {
  foo()
} catch {
  case ex: SomeException => /* ignore */
  case ex: SomeOtherException => /* ignore */
}

Göz ardı edilen bir kontrol yapısı ile, daha kısaca ve daha okunaklı olarak şöyle yazabilirsiniz:

ignoring(classOf[SomeException], classOf[SomeOtherException]) {
  foo()
}

[Scala bunu (ve diğer birçok İstisna işleme kontrol yapısını) standart kütüphanesinde util.control paketinde sunar. ]

Onun yerine:

switch(myEnum) {
  case MyEnum.Val1: do1(); ...
  case MyEnum.Val2: do2(); ...
....

Python veya şimdi C # yolunu yapın:

action = val2func[myEnum]
action()

Scala'nın birçok yeni özelliği var.

Son olarak, ekstra işlevsellik sağlamak için Clojure gibi diller genişletilebilir.

İki fikrim var.

Genellikle ben olduğumu bulmak kendimi tekrar içinde catchbloklar. Bu, yöntemlerin çıkarılmasıyla biraz yardımcı olabilir, ancak yöntemler çok kısasa veya başka bir yönteme layık değilse, gereksiz dağınıklığa neden olabilir. Yani, catchblokları yerleştirmek güzel olurdu :

try {
    // Save something
} catch (Exception e) {
    // Something we do for all Exceptions
    catch (ProcessingException e) {
        // Something we do for all Processing exceptions
        catch (DBExcpetion e) {
            // DBExceptions are a subclass of ProcessingException
        }
        catch (BusinessRuleException e) {
            // BusinessRuleExceptions are also a subclass of ProcessingException
        }
    }
    // Something we do after specific sub class Exceptions
 }

Web programlamada sık sık kendimi sık sık böyle bir şey yapıyorum (bu gerçek bir örnek değil, bu yüzden kurgusal vakaları analiz etmeyin):

Account a = getSavedAccount();
if (a == null) {
    a = getAccountFromSessionId();
}
if (a == null) {
    a = getAccountFromCookieId();
}
if (a == null) {
    a = createNewAccount();
}

Javascript'te (iyi, ECMAScript ve belki de bilmediğim diğerleri), çünkü herhangi bir değer bir koşul olarak değerlendirilebilir ||, yardımcı olabilir.

var a = getAFromLocation1() || getAFromLocation2() || default;

Bunun nasıl göründüğünü gerçekten çok seviyorum ve daha fazla dil, özellikle de sunucu tarafında bazılarının destek vermesini diliyorum. (PHP her şeyi koşul olarak değerlendirebilir, ancak değeri korumak yerine tüm koşullu ifadeyi bir boole'ye dönüştürür. Python veya Ruby hakkında bilmiyorum.) Üç durumdan sonra uygunsuz olabilir, ancak daha fazlasına sahipseniz üç durumdan daha kötü bir yazılım tasarımına sahip olabilirsiniz.

Genel anahtar yukarıda söyledi:

 switch(x){
  predicate1:
     dosomething();
  predicate2:
     dosomethingelse();
 }

Haskell'de:

  switch' :: a -> [(a -> Bool, b)] -> b
  switch' a [] = undefined
  switch' a (f,b):xs = if f a
                     then b
                      else switch' a xs

C # ben basit switch () { ... }, ama bu tür ifadelerle genişletilebilir kullanmak istiyorum :

switch (value)
{
  // string-based operators:
  case begins "Maria": // to catch Maria Carey
    break;
  case ends "Washington": // to catch George Washington
    break;
  case like "ph": // to catch Phil, Phillip, Sophie
    break;
  case between "Aaron" and "April": // to catch all names between
    break;

  // use non-static variables in case expression:
  case Dao.GetDefaultBabyName():
    break;

  // continuable cases without breaking
  case "John":
    bonus = 25;
  case "Peter":
    salary = 500;
    break;

  // jumps between cases
  case "Aleron":
    // do something
    break;
  case "Bella":
    // do something
    jump "Aleron";
    break;

}

Ve bunun gibi. Numaraları veya diğer türdeki (yani destekler IComparable, IConvertible, ...)

Bu, kodumu daha özlü ve okunabilir hale getirebilir.

@Macneil'in dediği gibi eğlenceli bir soru.

Benim (mütevazı öksürük) keşfettiğim en sevdiğim olağandışı kontrol yapısı, diferansiyel uygulama .

Bazı kullanımları vardır. Benim için ezici kullanım, gereksiz verileri yazışmada tutmanın daha genel probleminin bir örneği olan kullanıcı arayüzlerini programlamaktır. Bir yandan uygulama verileri var, diğer yandan da anlaşmaya varılması gereken UI kontrolleri var. Bu "bağlayıcı" gibi geliyor ama aslında çok daha fazlası var.

Genellikle C veya C ++ 'da makrolarla uygularım. C # bunu el genişleyen ifadeler ile yapmak zorunda. Bu bir acı, ama işe yarıyor.

Bir keresinde Lisp makroları açısından uyguladım ve sonra çok temizdi. Programcının dikkatine ihtiyaç duymadı. Tam bir ayrıştırıcı yazmak ve daha sonra tüm doğru şeyleri üretmek için sorun çıkarırsam, başka bir yapısal dilde de aynı şeyi yapabilirdim. Bu büyük bir proje ve ben yapmadım.

"Geleneksel" kontrol yapıları for, çalışan adamı kontrol etmek ve onu iktidardaki kapitalist seçkinlerin yozlaşmış ideolojilerine bağlı tutmakla ilgilidir. Bu yüzden ph0rbunun yerine alternatif kontrol yapıları kullanıyorum. Bu for, ama daha radikal: ph0rBir takım kurumsal BS'i tükürerek bir takım elbise ve kravat takmayacaksınız. ph0rgerçek tutar dostum.

Güçle savaş!

En basit fordöngü

for(100)
{
    //Will run for 100 times
}


for(i)
{
    //Will run for i times while i must be a positive integer
}


for(i as a)
{
    //Will run for i times while i must be a positive integer
    //and a is the incremental loop variable starting from 0 and 
    //scoped within the loop
}


for(i as a=2)
{
    //Will run for i times while i must be a positive integer
    //and a is the incremental loop variable starting from 2 and 
    //scoped within the loop
}