Welche nützlichen alternativen Kontrollstrukturen kennen Sie? [geschlossen]

Ähnliche Frage wurde auf SO geschlossen.

Manchmal stellen wir beim Programmieren fest, dass eine bestimmte Kontrollstruktur für uns sehr nützlich ist, aber nicht direkt in unserer Programmiersprache verfügbar ist.

Welche alternativen Kontrollstrukturen sind Ihrer Meinung nach eine nützliche Möglichkeit, die Berechnung zu organisieren?

Ziel ist es, neue Denkansätze für die Strukturierung von Code zu entwickeln, um Chunking und Argumentation zu verbessern.

Sie können eine wünschenswerte Syntax / Semantik erstellen, die derzeit nicht verfügbar ist, oder eine weniger bekannte Kontrollstruktur für eine vorhandene Programmiersprache angeben.

Die Antworten sollten Anregungen für eine neue Programmiersprache oder die Verbesserung einer tatsächlichen Sprache geben.

Stellen Sie sich das als Brainstorming vor. Stellen Sie also etwas auf, das Ihrer Meinung nach eine verrückte Idee ist, aber in manchen Szenarien durchaus machbar ist.

Es geht um zwingende Programmierung.

OK, das ist eine lustige Frage.

Ich hätte auch gerne einen General elsefür eine Weile und für Schleifen, wenn die Bedingung beim ersten Test nicht erfüllt ist :

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

Dies vermeidet die umständliche Neuberechnung der Bedingung oder deren Speicherung in einer Variablen.

Warum nicht ein paar Antworten zu einer zusammenfügen?

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.

Eine erweiterbare, verallgemeinerte Syntax für Flusssteuerungskonstrukte in einer imperativen Sprache wäre ziemlich nützlich und unterhaltsam. Bis das auftaucht, werde ich wohl nur Lisp oder so was benutzen.

Kontrollstrukturen als Funktionen.

Ich will for, if, else, while, etc. Funktionen sein, keine besonderen Strukturen.

Ich möchte return, try/exceptund gotoDerivate von Fortsetzungen sein.

Dies hat natürlich weniger mit einer bestimmten Kontrollstruktur zu tun als vielmehr damit, wie Sie Kontrollstrukturen im Allgemeinen sehen, die Meta von Kontrollstrukturen.

In dem verlinkten Artikel geht es definitiv um Donald Knuths N + 1/2-Loops . In C / C ++ / Java ausgedrückt:

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

Dies ist nützlich, um Zeilen oder Zeichen aus einer Datei zu lesen, um zu prüfen, ob Sie EOF erreicht haben, und um sie dann zu verarbeiten. Ich bin es so gewohnt, das Muster zu sehen for(;;)..if(..)break;, dass es für mich idiomatisch ist. (Bevor ich den Artikel von Knuth gelesen hatte, der im Buch Literate Programming abgedruckt war , war dieser ein "wtf?".)

Knuth schlug die Schlüsselwörter vor loop/while/repeat:

loop:
  S;
while C:
  T;
repeat

Wo Sund Tsind Platzhalter für eine Reihe von null oder mehr Anweisungen und Cist eine boolesche Bedingung. Wenn es keine SAnweisung gäbe, wäre es eine while-Schleife, und wenn es keine TAnweisung gäbe, wäre es eine do-Schleife.

Dieses Konstrukt selbst könnte verallgemeinert werden, indem null oder mehr while CKlauseln zugelassen werden, was es perfekt macht, um Endlosschleifen und dann einige seltenere Bedingungen auszudrücken, die zwei Überprüfungen erfordern würden.

Im selben Artikel schlug Knuth einen Signalisierungsmechanismus vor, der eine lokale Version von Ausnahmen für das Werfen / Fangen von Ausnahmen ist (als Alternative zur Verwendung von goto).

Für mich? Ich wünsche mir, dass Java die Tail-Call-Optimierung unterstützt, damit ich bei Bedarf eine allgemeine Kontrollstruktur ausdrücken kann .

Update: Ich habe vergessen zu erwähnen, dass viele C / C ++ / Java-Programmierer dieses Problem umgehen, indem sie eine eingebettete Zuweisung verwenden, unter der Bedingung, dass while:

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

Unter Verwendung der Begriffe aus Knuths Konstrukt ist dies zulässig, wenn Sund Ckann zu einem einzigen Ausdruck kombiniert werden. Einige Leute hassen es, die eingebettete Aufgabe oben zu sehen, während andere es hassen, breakdie for (;;)oben genannte Aufgabe zu sehen . Aber wenn Sund Ckann nicht kombiniert werden, beispielsweise wenn Smehrere Anweisungen hat, das for (;;)ist die einzige Alternative , ohne Code zu wiederholen. Die andere Alternative besteht darin, den SCode einfach zu duplizieren :

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

Knuths loop/while/repeatAlternative scheint viel besser zu sein.

Die BCPL-Sprache hatte einen valueofAusdruck , mit dem eine Folge von Anweisungen in einen einzelnen Ausdruck umgewandelt werden konnte:

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

Wo some series of statementskann irgendetwas sein und das ganze valueofauswerten v.

Dies kann in Java nützlich sein, wenn Sie ein Argument für den Aufruf von a this()oder berechnen müssen super()(was voraussetzt, dass davor nichts passiert). Natürlich können Sie auch nur eine separate Methode schreiben, aber das kann schwierig sein, wenn Sie viele lokale Werte für den Kontext übergeben müssen.

Wenn Sie finalVariablen verwenden können, die benötigt werden, können Sie valueofin Java bereits anonyme innere Klassen verwenden:

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

unless(condition) {
  // ...
}

macht dasselbe wie:

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

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

macht dasselbe wie:

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

In einem anderen Sinne würde ich mir eine bessere Unterstützung für Iteratoren in Programmiersprachen wünschen. Insbesondere, wenn Sie zwei Sammlungen paarweise durchsuchen möchten :

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

Einige dynamische Sprachen haben dies möglicherweise bereits oder können problemlos über Bibliotheken und Makros unterstützt werden, aber ich denke, dies liegt im Geiste Ihrer Frage.

Wenn die beiden Mengen nicht die gleiche Größe haben, kann es zu einer Ausnahme kommen, oder Sie können elsenach der Schleife eine Meldung anzeigen, dass ein Größenunterschied vorliegt.

Sie können dies natürlich verallgemeinern, indem Sie drei oder mehr Listen durchgehen.

Update: Auch nützlich wäre es, das kartesische Produkt zwischen iterablen zu machen:

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

Das wäre nichts anderes als verschachtelte Schleifen:

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

Ich bin ein wenig besorgt, dass zwischen den beiden Notationen, die ich hier angegeben habe, ein Unterschied in der Anzahl der Paare zwischen O (n) und O (n ^ 2) besteht, mit nur der Änderung eines einzelnen Zeichens.

Es gibt sogenannte "Dijkstra's Loop" (auch "Dijkstra's Guarded Loop" genannt). Es wurde in der Guarded Command Language (GCL) definiert . Informationen zu Syntax und Semantik finden Sie im obigen Wikipedia-Artikel in Abschnitt 6 Repetition: do .

Heutzutage kenne ich tatsächlich eine Programmiersprache, die dieses Kontrollmuster direkt unterstützt. Es ist Oberon-07 (PDF, 70 KB). Und es unterstützt "Dijkstra's Loop" in Form einer while-Anweisung. Schauen Sie sich Abschnitt 9.6 an. Während Aussagen im obigen PDF.

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

PS Dies ist eine Kopie meiner SO-Antwort .

Icon-ähnliche Ausdrücke mit integriertem Backtracking.

Python profitiert von vielen Vorteilen des Icon-Generators - und macht dies im Allgemeinen besser, IMO. Und im Prinzip war das Backtracking nur eine Art Ausnahmewurf, aber es war die Einfachheit der Ausdrücke, die grobe Entsprechung von ...

x = (a / b) else c;

Fehlerfälle wie Division durch Null zu behandeln.

Wo Icon durchgedreht ist - keine Vergleichsoperatoren, die Boolesche Werte zurückgeben. Die Vergleiche waren immer erfolgreich oder haben ein Zurückverfolgen ausgelöst, und es gab ein anderes semantisches Problem, an das ich mich jetzt verzweifelt zu erinnern versuche.

Ich habe immer gedacht, sie sollten einen ifAusdruck haben, der nichts anderes enthält if (condition, success-value), und zurückverfolgen, wenn die Bedingung falsch ist - und die seltsamen Vergleiche fallen lassen.

EDIT Ich erinnere mich - offensichtlich wirklich. Ein Vergleich mit zwei Argumenten ist entweder erfolgreich oder schlägt fehl - es wird kein neuer zurückzugebender Wert berechnet. Also, wenn es gelingt, was kehrt es zurück? Antwort - eines der Argumente. Aber wenn Sie schreiben a > b, welches ist das logische Argument, um zurückzukehren - aoder b? Und wenn du b < astattdessen schreibst ? Ich denke, es hat immer das richtige Argument geliefert, was genauso viel Sinn macht wie alles andere, aber es schien mir immer noch das falsche Argument zu sein.

Dies ist nur eine allgemeine Idee und Syntax:

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

AUCH Bedingung wird immer ausgewertet. ELSE funktioniert wie gewohnt.

Es funktioniert auch für den Fall. Wahrscheinlich ist es eine gute Möglichkeit, die break-Anweisung zu eliminieren:

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

kann gelesen werden als:

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

Ich weiß nicht, ob dies nützlich oder einfach zu lesen ist, aber es ist ein Beispiel.

Continuation Passing Style fällt mir ein. Dann möchten Sie natürlich auch Tail Call Optimization haben .

Die nahtlose Thread-Verzweigung hat eine Syntax wie eine Funktion, wird jedoch in einem separaten Thread ausgeführt und kann nicht auf Daten zugreifen, die ursprünglich nicht an ihn übergeben wurden.

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

Wenn ein Zweig aufgerufen wird, wird sofort ein Handle zurückgegeben.

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

Mit dem Handle kann überprüft werden, ob die Aufgabe erledigt ist.

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

Wenn das Ergebnis angefordert wird, bevor die Ausführung abgeschlossen ist, wartet der Haupt-Thread einfach.

[result, storage]=handle.result()

Dies würde nicht die fortgeschritteneren Multithreading-Szenarien abdecken, sondern eine leicht zugängliche Möglichkeit bieten, mehrere Kerne zu nutzen.

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

Der Block FIRST und THEN wird ausgeführt, wenn eine der drei Bedingungen als wahr ausgewertet wird. Der ERSTE Block wird vor dem bedingten Block ausgeführt, und DANN wird ausgeführt, nachdem der bedingte Block ausgeführt wurde.

ELSE bedingte oder endgültige Schreibvorgänge nach der Anweisung FIRST und THEN sind von diesen Blöcken unabhängig.

Es kann lauten:

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

Diese Funktionen sind nur ein Formular zum Lesen. Sie würden keinen Spielraum schaffen. Es ist eher ein Gosub / Return von Basic.

Nützlichkeit und Lesbarkeit als Diskussionsgegenstand.

Manchmal schreibe ich eine Schleife, die während der ersten Iteration etwas anderes machen muss. Beispiel: Anzeigen von <th> -Tags anstelle von <td> -Tags.

Ich behandle diese Situation mit einer Booleschen Flagge. Etwas wie das:

first = true

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

Es erscheint dumm, den Wert firstjeder Iteration zu überprüfen, wenn er die meiste Zeit falsch sein wird.

Ich hätte gerne eine Loop-Option, um bei der ersten Iteration einen anderen Loop-Body anzugeben. Es wäre keine separate Variable erforderlich. Der kompilierte Code würde auch keinen benötigen, da der generierte Code zwei Körper haben würde, einen für die erste Iteration und einen für den Rest.

[kopiert von meiner eigenen Antwort auf stackoverflow]

ignoring - Um Ausnahmen zu ignorieren, die in einem bestimmten Codeblock auftreten.

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

Mit einem ignorierenden Kontrollkonstrukt könnten Sie es übersichtlicher und lesbarer schreiben als:

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

[Scala stellt dieses (und viele andere Ausnahmebehandlungs-Steuerungskonstrukte) in seiner Standardbibliothek im Paket util.control zur Verfügung. ]

Anstatt von:

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

Mach es mit Python oder jetzt auch mit C #:

action = val2func[myEnum]
action()

Scala hat viele neue Funktionen.

Schließlich können Sprachen wie Clojure erweitert werden, um die zusätzliche Funktionalität bereitzustellen.

Ich habe zwei Ideen.

Oft stelle ich fest, dass ich mich in catchBlöcken wiederhole . Dies kann etwas durch Extrahieren von Methoden geholfen werden, aber dies kann zu unnötigem Durcheinander führen, wenn die Methoden sehr kurz sind oder anderweitig keine Methode wert sind. Es wäre also schön, catchBlöcke zu verschachteln :

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
 }

In der Web-Programmierung tue ich oft so etwas (dies ist kein wirkliches Beispiel, also analysiere keine fiktiven Fälle):

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

In Javascript (naja, ECMAScript und vielleicht anderen, mit denen ich nicht vertraut bin) ||kann es helfen , da jeder Wert als Bedingung bewertet werden kann.

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

Ich mag es wirklich, wie das aussieht, und ich wünschte, mehr Sprachen, insbesondere einige auf der Serverseite, hätten Unterstützung dafür. (PHP kann alles als Bedingung auswerten, konvertiert aber den gesamten Bedingungsausdruck in einen Booleschen Ausdruck, anstatt den Wert beizubehalten. Ich weiß nicht, wie Python oder Ruby aussehen.) Nach drei oder mehr Fällen könnte es unhandlich werden, aber wenn Sie mehr haben In mehr als drei Fällen liegt möglicherweise auch ein fehlerhaftes Software-Design vor.

Der verallgemeinerte Schalter hat oben gesagt:

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

In Haskell:

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

In C # möchte ich einfache switch () { ... }, aber mit solchen Ausdrücken erweiterbare verwenden:

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;

}

Und so weiter. Das gleiche mit Zahlen oder anderen Typen (dh Träger IComparable, IConvertible...)

Dies könnte meinen Code lakonischer und lesbarer machen.

Es ist eine lustige Frage, wie @Macneil sagte.

Meine ungewöhnliche Lieblingskontrollstruktur, die ich (demütiger Husten) entdeckt habe, ist die differentielle Ausführung .

Es hat bestimmte Verwendungen. Die überwältigende Verwendung besteht für mich in der Programmierung von Benutzeroberflächen, was ein Beispiel für das allgemeinere Problem ist, redundante Daten in Übereinstimmung zu halten. Auf der einen Seite gibt es Anwendungsdaten und auf der anderen Seite gibt es Benutzeroberflächen-Steuerelemente, die in Übereinstimmung gehalten werden müssen. Das klingt nach "Bindung", aber es steckt noch viel mehr dahinter.

Normalerweise implementiere ich es durch Makros in C oder C ++. In C # muss ich es durch handexpandierende Anweisungen tun. Das ist ein Schmerz, aber es funktioniert.

Einmal habe ich es in Form von Lisp-Makros implementiert und dann war es sehr sauber. Es erforderte keine Sorgfalt seitens des Programmierers. Ich hätte das Gleiche in jeder anderen strukturierten Sprache tun können, wenn ich mir die Mühe gemacht hätte, einen vollständigen Parser zu schreiben und dann alles Richtige zu generieren. Das ist ein großes Projekt, und ich habe es nicht getan.

Bei "traditionellen" Kontrollstrukturen geht fores darum, den Arbeiter zu kontrollieren und ihn den korrupten Ideologien der herrschenden kapitalistischen Elite zu unterwerfen. Deshalb verwende ich ph0rstattdessen alternative Kontrollstrukturen wie . Es ist wie for, aber radikaler: Sie werden es nicht fangen ph0r, einen Anzug und eine Krawatte zu tragen, die etwas Corporate BS ausstoßen. ph0rhält es echt, Mann.

Kämpfe gegen die Macht!

Einfachstes forLoop-

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
}