Những cấu trúc điều khiển thay thế hữu ích nào bạn biết? [đóng cửa]

Câu hỏi tương tự đã được đóng lại trên SO.

Đôi khi, khi chúng tôi lập trình, chúng tôi thấy rằng một số cấu trúc điều khiển cụ thể sẽ rất hữu ích cho chúng tôi, nhưng không có sẵn trực tiếp trong ngôn ngữ lập trình của chúng tôi.

Những cấu trúc điều khiển thay thế nào bạn nghĩ là một cách hữu ích để tổ chức tính toán?

Mục tiêu ở đây là để có được những cách nghĩ mới về cấu trúc mã, để cải thiện sự phân chia và lý luận.

Bạn có thể tạo một cú pháp mong muốn / ngữ nghĩa không có sẵn ngay bây giờ hoặc trích dẫn một cấu trúc điều khiển ít được biết đến trên một ngôn ngữ lập trình tồn tại.

Câu trả lời nên đưa ra ý tưởng cho một ngôn ngữ lập trình mới hoặc tăng cường một ngôn ngữ thực tế.

Hãy nghĩ về điều này như là động não, vì vậy hãy đăng một cái gì đó bạn nghĩ là một ý tưởng điên rồ nhưng nó có thể khả thi trong một số tình huống.

Đó là về lập trình bắt buộc.

OK, đây là một câu hỏi thú vị.

Tôi cũng muốn có một vị tướng elsetrong một thời gian và cho các vòng lặp, khi điều kiện không đúng trong bài kiểm tra đầu tiên :

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

Điều này tránh sự tính toán lại vụng về của điều kiện hoặc lưu trữ nó trong một biến.

Tại sao không nghiền một vài câu trả lời thành một?

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.

Một cú pháp xây dựng kiểm soát dòng chảy mở rộng, tổng quát trong một ngôn ngữ bắt buộc sẽ khá hữu ích và giải trí. Cho đến khi điều đó xuất hiện, đoán tôi sẽ chỉ sử dụng Lisp hoặc một cái gì đó.

Cấu trúc điều khiển như các chức năng.

Tôi muốn for, if, else, while, vv để có chức năng, không phải cấu trúc đặc biệt.

Tôi muốn return, try/exceptvà gotolà dẫn xuất của sự tiếp nối.

Tất nhiên điều này ít liên quan đến một cấu trúc điều khiển cụ thể và nhiều thứ khác liên quan đến cách bạn nhìn thấy các cấu trúc điều khiển nói chung, meta của các cấu trúc điều khiển.

Bài viết được liên kết chắc chắn hiểu đúng về Vòng lặp N + 1/2 của Donald Knuth . Thể hiện bằng C / C ++ / Java:

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

Điều này hữu ích để đọc các dòng hoặc ký tự từ một tệp, kiểm tra xem bạn đã đạt EOF chưa, và sau đó xử lý nó. Tôi đã quá quen với việc nhìn thấy mô hình for(;;)..if(..)break;xuất hiện rằng nó là thành ngữ đối với tôi. (Trước khi tôi đọc bài báo Knuth, được in lại trong cuốn sách Lập trình văn học , bài này đã từng là "wtf?".)

Knuth đề xuất các từ khóa loop/while/repeat:

loop:
  S;
while C:
  T;
repeat

Trường hợp Svà Tlà chủ sở hữu vị trí cho một loạt các câu lệnh bằng 0 hoặc nhiều hơn và Clà một điều kiện boolean. Nếu không có Scâu lệnh thì đó sẽ là một vòng lặp while và nếu không có Tcâu lệnh thì đó sẽ là một vòng lặp do.

Bản thân cấu trúc này có thể được khái quát bằng cách cho phép không hoặc nhiều while Cmệnh đề, làm cho nó hoàn hảo để thể hiện các vòng lặp vô hạn và sau đó một số điều kiện hiếm hơn sẽ cần hai kiểm tra.

Trong cùng một bài viết, Knuth đã đề xuất một cơ chế báo hiệu sẽ là một phiên bản cục bộ của các trường hợp ném / bắt ngoại lệ (như là một cách thay thế cho việc sử dụng goto).

Cho tôi? Tôi muốn Java hỗ trợ tối ưu hóa cuộc gọi đuôi, để tôi có thể diễn đạt bất kỳ cấu trúc điều khiển chung nào khi cần.

Cập nhật: Tôi quên đề cập rằng nhiều lập trình viên C / C ++ / Java đã khắc phục điều này bằng cách sử dụng một bài tập được nhúng trong điều kiện while:

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

Sử dụng các thuật ngữ từ cấu trúc của Knuth, điều này được phép khi Svà Ccó thể được kết hợp thành một biểu thức. Một số người ghét nhìn thấy bài tập được nhúng ở trên, trong khi những người khác ghét nhìn thấy phần breakở for (;;)trên. Nhưng khi Svà Ckhông thể được kết hợp, chẳng hạn như khi Scó nhiều câu lệnh, thì câu lệnh for (;;)thay thế duy nhất mà không lặp lại mã. Cách khác là đơn giản là sao chép Smã:

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

Sự loop/while/repeatthay thế của Knuth có vẻ tốt hơn nhiều.

Ngôn ngữ BCPL có một valueofbiểu thức có thể được sử dụng để biến một chuỗi các câu lệnh thành một biểu thức:

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

Nơi some series of statementscó thể là bất cứ điều gì và toàn bộ valueofđánh giá v.

Điều này có thể có ích trong Java khi bạn cần tính toán một đối số để gọi một this()hoặc super()(yêu cầu không có gì xảy ra trước nó). Tất nhiên, bạn chỉ có thể viết một phương thức riêng biệt, nhưng đó có thể là một nỗi đau nếu bạn cần truyền vào nhiều giá trị cục bộ cho ngữ cảnh.

Nếu bạn có thể sử dụng finalcho các biến cần thiết, bạn đã có thể thực hiện valueoftrong Java bằng các lớp bên trong ẩn danh:

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

unless(condition) {
  // ...
}

thực hiện tương tự như:

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

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

thực hiện tương tự như:

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

Một lưu ý khác, tôi muốn thấy sự hỗ trợ tốt hơn cho các trình vòng lặp trong các ngôn ngữ lập trình. Đặc biệt, khi bạn muốn đi xuống hai bộ sưu tập theo cặp :

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

Một số ngôn ngữ động có thể đã có điều này hoặc dễ dàng hỗ trợ thông qua các thư viện và macro, nhưng tôi nghĩ rằng đây là tinh thần của câu hỏi của bạn.

Nếu hai bộ không cùng kích thước, thì nó có thể đưa ra một ngoại lệ hoặc bạn có thể có một elsevòng lặp sau để báo hiệu có sự khác biệt về kích thước.

Đương nhiên, bạn có thể khái quát hóa điều này để đi xuống ba danh sách trở lên.

Cập nhật: Cũng hữu ích khi thực hiện sản phẩm Cartesian giữa các lần lặp:

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

đó sẽ không là gì ngoài các vòng lặp lồng nhau:

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

Tôi có một chút lo ngại rằng giữa hai ký hiệu tôi đã cung cấp ở đây có sự khác biệt về số lượng cặp O (n) và O (n ^ 2), chỉ có sự thay đổi của một ký tự.

Có cái gọi là "Vòng lặp của Dijkstra" (còn được gọi là "Vòng bảo vệ của Dijkstra"). Nó được định nghĩa trong Ngôn ngữ lệnh được bảo vệ (GCL) . Bạn có thể tìm thấy một số thông tin về cú pháp và ngữ nghĩa của nó trong bài viết Wikipedia ở trên tại phần 6 Lặp lại: do .

Ngày nay tôi thực sự biết một ngôn ngữ lập trình hỗ trợ chiến lược điều khiển này trực tiếp. Đó là Oberon-07 (PDF, 70 KB). Và nó hỗ trợ "Dijkstra's Loop" dưới dạng câu lệnh while. Hãy xem phần 9.6. Trong khi các tuyên bố trong PDF trên.

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

PS Đây là bản sao câu trả lời SO của tôi .

Biểu thức kiểu biểu tượng với tính năng quay lui tích hợp.

Python nhận được rất nhiều lợi ích của Trình tạo biểu tượng - và nói chung là thực hiện tốt hơn chúng, IMO. Và về nguyên tắc, việc quay lại chỉ là một kiểu ném ngoại lệ, nhưng đó là sự đơn giản của các biểu thức tương đương với ...

x = (a / b) else c;

để xử lý các trường hợp thất bại như chia cho số không.

Trường hợp Icon bị hỏng - không có toán tử so sánh trả về boolean. Các so sánh luôn luôn thành công hoặc kích hoạt quay lui, và có một số vấn đề ngữ nghĩa khác mà bây giờ tôi đang cố gắng để nhớ rằng ... tốt, hãy nói rằng nó có lẽ bị đè nén nhiều hơn là bị lãng quên.

Tôi luôn nghĩ rằng họ nên có một ifbiểu hiện không có phần nào khác - if (condition, success-value)loại điều, quay lại nếu điều kiện trả về sai - và bỏ các so sánh kỳ lạ.

EDIT tôi nhớ - rõ ràng thực sự. So sánh với hai đối số thành công hoặc thất bại - nó không tính toán một giá trị mới để trả về. Vì vậy, khi nó thành công, những gì không nó trở lại? Trả lời - một trong những lý lẽ. Nhưng nếu bạn viết a > b, đó là đối số hợp lý để trả về - ahoặc b? Và nếu bạn viết b < athay thế thì sao? Tôi nghĩ rằng nó luôn trả về đúng đối số, điều này có ý nghĩa như mọi thứ, nhưng nó vẫn thường có vẻ như là đối số sai đối với tôi.

Đây chỉ là một ý tưởng chung và cú pháp:

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

Điều kiện CSONG luôn được đánh giá. ELSE hoạt động như bình thường.

Nó hoạt động cho trường hợp quá. Có lẽ đó là một cách tốt để loại bỏ tuyên bố phá vỡ:

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

có thể được đọc là:

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

Tôi không biết điều này hữu ích hay đơn giản để đọc nhưng đó là một ví dụ.

Phong cách tiếp tục đến với tâm trí. Sau đó, tất nhiên, bạn cũng muốn có Tối ưu hóa cuộc gọi đuôi .

Phân nhánh luồng liền mạch, nó có cú pháp giống như một hàm, nhưng thực thi trong một luồng riêng biệt và không thể truy cập dữ liệu ban đầu không được truyền cho nó.

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

Khi một nhánh được gọi nó sẽ ngay lập tức trả về một tay cầm.

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

Tay cầm có thể được sử dụng để kiểm tra nếu tác vụ được thực hiện.

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

Nếu kết quả được yêu cầu trước khi thực hiện xong, luồng chính sẽ chỉ chờ.

[result, storage]=handle.result()

Điều này sẽ không bao gồm các kịch bản đa luồng nâng cao hơn, mà là cung cấp một cách dễ dàng bắt đầu để sử dụng nhiều lõi.

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

Các khối FIRST và THEN chạy nếu bất kỳ 3 điều kiện nào được đánh giá là đúng. Khối FIRST chạy trước khối điều kiện và THEN chạy sau khi khối điều kiện đã chạy.

ELSE có điều kiện hoặc viết cuối cùng sau câu lệnh FIRST và THEN độc lập với các khối này.

Nó có thể đọc là:

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

Các chức năng này chỉ là một hình thức để đọc. Họ sẽ không tạo ra phạm vi. Nó giống như một gosub / trở về từ Basic.

Hữu ích và dễ đọc như là vấn đề thảo luận.

Đôi khi tôi thấy mình viết một vòng lặp cần phải làm một cái gì đó khác biệt trong lần lặp đầu tiên. Ví dụ: hiển thị thẻ <th> thay vì thẻ <td>.

Tôi xử lý tình huống này với một cờ boolean. Một cái gì đó như thế này:

first = true

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

Có vẻ ngớ ngẩn khi kiểm tra giá trị của firstmỗi lần lặp khi nó sẽ sai hầu hết thời gian.

Tôi muốn có một tùy chọn lặp để chỉ định một thân vòng lặp khác nhau trong lần lặp đầu tiên. Sẽ không cần một biến riêng biệt. Mã được biên dịch sẽ không cần một, bởi vì mã được tạo sẽ có hai thân, một cho lần lặp đầu tiên và một cho phần còn lại.

[được sao chép từ câu trả lời của riêng tôi trên stackoverflow]

ignoring - Để bỏ qua các ngoại lệ xảy ra trong một khối mã nhất định.

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

Với cấu trúc điều khiển bỏ qua, bạn có thể viết nó chính xác hơn và dễ đọc hơn như:

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

[Scala cung cấp điều này (và nhiều cấu trúc điều khiển xử lý ngoại lệ khác) trong thư viện chuẩn của nó, trong gói produc.control. ]

Thay vì:

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

Làm điều đó với Python, hoặc bây giờ là cách C #:

action = val2func[myEnum]
action()

Scala có rất nhiều tính năng mới.

Cuối cùng, các ngôn ngữ như Clojure có thể được mở rộng để cung cấp chức năng bổ sung.

Tôi có hai ý tưởng.

Thường thì tôi thấy rằng tôi đang lặp lại chính mình trong catchcác khối. Điều này có thể được giúp đỡ phần nào thông qua các phương pháp trích xuất, nhưng điều đó có thể gây ra sự lộn xộn không cần thiết nếu các phương thức này rất ngắn hoặc nếu không thì không xứng đáng với một phương pháp. Vì vậy, sẽ rất tốt nếu lồng catchcác khối:

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
 }

Trong lập trình web, tôi cũng thường thấy mình thường làm một việc như thế này (đây không phải là một ví dụ thực tế vì vậy đừng phân tích các trường hợp hư cấu):

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

Trong Javascript (tốt, ECMAScript và có thể những người khác mà tôi không quen thuộc), vì bất kỳ giá trị nào cũng có thể được đánh giá là điều kiện, ||có thể giúp ích.

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

Tôi thực sự thích vẻ ngoài đó và tôi muốn nhiều ngôn ngữ hơn, đặc biệt là một số ngôn ngữ ở phía máy chủ, đã hỗ trợ cho nó. (PHP có thể đánh giá bất cứ điều gì như một điều kiện, nhưng chuyển đổi toàn bộ biểu thức điều kiện thành boolean thay vì bảo toàn giá trị. Tôi không biết về Python hoặc Ruby.) Nó có thể trở nên khó sử dụng sau ba trường hợp hoặc hơn, nhưng nếu bạn có nhiều hơn hơn ba trường hợp, bạn cũng có thể có một thiết kế phần mềm xấu.

Công tắc tổng quát đã nói ở trên:

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

Trong Haskell:

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

Trong C # tôi muốn sử dụng đơn giản switch () { ... }, nhưng có thể mở rộng với các biểu thức như vậy:

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;

}

Và như thế. Cùng với những con số hoặc các loại khác (hỗ trợ mà IComparable, IConvertible...)

Điều này có thể làm cho mã của tôi trở nên gọn gàng và dễ đọc hơn.

Đó là một câu hỏi thú vị, như @Macneil nói.

Cấu trúc kiểm soát bất thường yêu thích của tôi, mà tôi (khiêm tốn ho) phát hiện ra, là thực thi khác biệt .

Nó có công dụng nhất định. Đối với tôi, việc sử dụng áp đảo là trong lập trình giao diện người dùng, đây là một ví dụ của vấn đề chung hơn về việc duy trì dữ liệu dư thừa tương ứng. Một mặt, có dữ liệu ứng dụng và mặt khác, có các điều khiển UI, cần phải được giữ trong thỏa thuận. Điều này nghe có vẻ như "ràng buộc" nhưng thực sự có nhiều hơn thế.

Thông thường tôi thực hiện nó bằng các macro trong C hoặc C ++. Trong C # tôi phải làm điều đó bằng các câu lệnh mở rộng bằng tay. Đó là một nỗi đau, nhưng nó hoạt động.

Khi tôi triển khai nó dưới dạng macro Lisp, và sau đó nó rất sạch sẽ. Nó không đòi hỏi sự cẩn thận từ phía lập trình viên. Tôi có thể đã làm điều tương tự trong bất kỳ ngôn ngữ có cấu trúc nào khác nếu tôi gặp khó khăn khi viết một trình phân tích cú pháp hoàn chỉnh và sau đó tạo ra tất cả các công cụ phù hợp. Đó là một dự án lớn, và tôi đã không thực hiện nó.

Các cấu trúc kiểm soát "truyền thống" giống như forvề việc kiểm soát người đàn ông làm việc, giữ cho anh ta kiên định với các hệ tư tưởng tham nhũng của giới tinh hoa tư bản cầm quyền. Đó là lý do tại sao tôi sử dụng các cấu trúc điều khiển thay thế như ph0rthay thế. Nó giống như for, nhưng triệt để hơn: Bạn sẽ không bắt gặp ph0rmặc một bộ đồ và cà vạt, phun ra một số BS công ty. ph0rgiữ cho nó thật, anh bạn

Chiến đấu chống lại quyền lực!

forVòng lặp đơn giản nhất-

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
}