Có một điều như một tuyên bố của người Viking khi không? [đóng cửa]

Có một tính năng ngôn ngữ hoặc ngôn ngữ có thể xử lý các trường hợp "khi"? Đó là, bất cứ khi nào một số điều kiện trở thành đúng, trong bất kỳ phạm vi hoặc bối cảnh nào, mã bổ sung đó có thể được chỉ định để thực thi không?

Lưu ý rằng điều này khác với một đơn giản if, phải trong một phạm vi cụ thể và được viết rõ ràng. Điều này khi mệnh đề gần giống như một ifđiều được áp dụng cho mọi trường hợp trong quá trình thực thi chương trình sau nó.

Câu hỏi của bạn không rõ ràng nhưng mẫu Người quan sát dường như là thứ bạn đang tìm kiếm http://en.wikipedia.org/wiki/Observer_potype

Cú pháp khôn ngoan, khá nhiều ngôn ngữ có một whentừ khóa, nhưng tôi không biết bất kỳ ngôn ngữ nào sử dụng nó theo cách bạn mô tả.

Mẫu 'khi X xảy ra, mẫu Y' là loại cốt lõi của lập trình hướng theo khía cạnh: thay vì xác định luồng tuyến tính, bạn móc các trình xử lý vào các điều kiện nhất định (còn gọi là 'đăng ký' vào 'sự kiện'). Kiểu lập trình này phổ biến trong các ứng dụng GUI, trong đó thói quen cốt lõi của chương trình là một bộ điều phối sự kiện.

Một số ngôn ngữ có các tính năng cú pháp mở rộng để cung cấp các cơ chế như vậy thông qua các cấu trúc ngôn ngữ; một ví dụ sẽ là C # với các đại biểu và sự kiện của nó:

// 'when btnOK is clicked, run HandleOKClick'
btnOK.Clicked += this.HandleOKClick;

Các ngôn ngữ khác sử dụng các cấu trúc OOP (mẫu Trình quan sát, trình lắng nghe sự kiện, v.v .; một ví dụ trong Java (Java của tôi hơi bị rỉ sét, vì vậy hãy chỉnh sửa):

Foobar f = this;
btnOK.registerClickHandler(
    new ClickHandler {
        public void handleClick(Event e) {
            f.handleOKClick(e);
        }
    });

Tuy nhiên, một cách tiếp cận khác là sử dụng các cuộc gọi lại cũ đơn giản. Ví dụ trong javascript:

var btnOK = $('btnOK');
btnOK.click(handleOKClick);

Không ai vẫn chưa đề cập INTERCAL 's COMEFROM :

COMEFROM ban đầu được nhìn thấy trong danh sách các hướng dẫn ngôn ngữ lắp ráp trò đùa (như 'CMFRM'). Nó đã được xây dựng trong một bài viết về Datamation của R. Lawrence Clark vào năm 1973, được viết để đáp lại lá thư của Edsger Dijkstra được coi là có hại. COMEFROM cuối cùng đã được triển khai trong biến thể C-INTERCAL của ngôn ngữ lập trình bí truyền INTERCAL cùng với 'COMEFROM được tính toán' tối nghĩa hơn. Ngoài ra còn có các đề xuất của Fortran cho 'COME TỪ được chỉ định' và từ khóa 'KHÔNG' (để bổ sung cho vòng lặp 'DO' hiện tại).

Vào ngày 1 tháng 4 năm 2004, Richie Hindle đã xuất bản một triển khai của cả GOTO và COMEFROM cho ngôn ngữ lập trình Python. Mặc dù được phát hành vào ngày Cá tháng Tư và không nhằm mục đích sử dụng nghiêm túc, cú pháp là hợp lệ và việc triển khai hoàn toàn có hiệu quả.

Ngôn ngữ Tcl có dấu vết trên các biến cho phép mã tùy ý được thực thi bất cứ khi nào một biến được đặt (hoặc đọc hoặc xóa, nhưng điều đó ít quan trọng hơn ở đây). Mã tùy ý đó có thể dễ dàng bao gồm việc đánh giá một biểu thức và thực thi một số mã nếu nó giữ. Hạn chế chính là trong khi bạn có thể làm điều này cho các biến cục bộ, thì nó thường không hữu ích lắm vì chúng có xu hướng có tuổi thọ rất ngắn, vì vậy những thứ như vậy thường bị giới hạn ở các biến toàn cục và không gian tên. (Tcl không có đóng cửa.)

Nhưng nếu bạn đang làm điều này, bạn nên cẩn thận. Mặc dù bạn không chính thức gặp vấn đề với reentrancy (dấu vết bị vô hiệu hóa trong suốt thời gian thực thi cơ thể), đây vẫn là một cách tuyệt vời để viết mã không rõ ràng và gây ra nhiều nhầm lẫn. Đây cũng là một ý tưởng thực sự khủng khiếp khi sử dụng nó với một biến vòng lặp (ngoài việc gỡ lỗi) vì hiệu năng có thể khá quan trọng.

Một ví dụ (dựa trên mã từ trang hướng dẫn được liên kết ở trên) minh họa.

set foo 1
set bar 2
proc doMult args {
    global foo bar foobar
    set foobar [expr {$foo * $bar}]
}
trace add variable foo write doMult
trace add variable bar write doMult
doMult

Từ thời điểm đó trở đi, bất cứ lúc nào $foohoặc $bartrở thành một số nguyên mới, $foobarsẽ trở thành sản phẩm của cả hai. Tự động.

Tcl cũng cho phép thiết lập mã để chạy trên các loại kích hoạt khác, chẳng hạn như thực thi lệnh, xóa lệnh, bộ hẹn giờ, dữ liệu có sẵn trên ổ cắm, v.v. Với thư viện Tk được thêm vào, điều này được mở rộng để bao gồm cả một tập hợp lớn các sự kiện GUI là tốt. Thật đúng khi nói rằng Tcl thực sự là một ngôn ngữ hướng sự kiện rất mạnh mẽ (ngay cả khi bạn có thể dễ dàng viết mã không bao giờ sử dụng bất kỳ tính năng nào trong số đó).

Một cái gì đó như xử lý sự kiện?

thay vì func () xử lý sự kiện

bạn nói khi sự kiện làm func

Hoặc, có thể một cuộc gọi lại trên một biến số cụ thể?

Có, có một từ khóa như vậy trong Perl, như một công cụ sửa đổi câu lệnh:

say 'Well done!'        when 'A';

Đây cũng là một phần của câu lệnh switch:

given ($foo) {
    when (/^abc/) { $abc = 1; }
    when (/^def/) { $def = 1; }
    when (/^xyz/) { $xyz = 1; }
    default { $nothing = 1; }
}

Điều này ( COMEFROMtuyên bố được mô tả trên Wikipedia) có tính không?

Tóm lược:

COMEFROM gần như trái ngược với GOTO ở chỗ nó có thể đưa trạng thái thực thi từ bất kỳ điểm tùy ý nào trong mã sang câu lệnh COMEFROM. Điểm trong mã nơi chuyển trạng thái xảy ra thường được cung cấp dưới dạng tham số cho COMEFROM. Việc chuyển giao xảy ra trước hay sau khi lệnh tại điểm chuyển được chỉ định tùy thuộc vào ngôn ngữ được sử dụng. Tùy thuộc vào ngôn ngữ được sử dụng, nhiều COMEFROM tham chiếu cùng một điểm khởi hành có thể không hợp lệ, không mang tính quyết định, được thực thi theo một mức độ ưu tiên được xác định hoặc thậm chí tạo ra sự thực thi song song hoặc theo cách khác như được thấy trong Intercal Threaded.

Bạn đang tìm kiếm một ngôn ngữ có câu lệnh đồng bộ hay không đồng bộ khi phát biểu?

Âm thanh giống như một mẫu sự kiện (/ đăng ký / gọi lại) đối với tôi.

Ví dụ

conditionOwner.Condition += listener.WhenCondition

Bất cứ khi nào chủ sở hữu điều kiện thông báo rằng điều kiện đã xảy ra, người nghe sẽ thực hiện KhiCondition ().

Bạn có thể sử dụng mẫu liên kết với bộ chuyển đổi để kiểm tra trạng thái của một số biến đầu vào (khi thay đổi) và tính toán điều kiện, sau đó có một thuộc tính đầu vào của người nghe được liên kết với đầu ra và hành động khi đầu vào đó bị thay đổi.

Về ngôn ngữ, ví dụ .NET (ví dụ C #) đã được xây dựng trong các đăng ký đồng bộ (sự kiện) và Phần mở rộng phản ứng (RX) của nó thêm các đăng ký không đồng bộ.

Mô tả nghe giống như một trình kích hoạt cơ sở dữ liệu được thiết kế để chờ một kịch bản nhất định và sau đó thực thi.

Từ Wikipedia:

Một trình kích hoạt cơ sở dữ liệu là mã thủ tục được thực thi tự động để đáp ứng với các sự kiện nhất định trên một bảng cụ thể hoặc dạng xem trong cơ sở dữ liệu. Kích hoạt chủ yếu được sử dụng để giữ tính toàn vẹn của thông tin trên cơ sở dữ liệu. Ví dụ: khi một bản ghi mới (đại diện cho một nhân viên mới) được thêm vào bảng nhân viên, các bản ghi mới cũng sẽ được tạo trong các bảng về thuế, kỳ nghỉ và tiền lương.

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

Những gì bạn đang nói là ít cú pháp hơn cấu trúc . Bạn thực sự chỉ có thể có một whencâu lệnh như thế trong một hệ thống thực thi một lượng logic hữu hạn, sau đó thực thi các whencâu lệnh, sau đó lặp lại và thực hiện lại logic, tiếp tục trong một vòng lặp vô hạn.

Ví dụ, lập trình Windows thường là "dựa trên sự kiện". Đăng ký vào Clicksự kiện của một nút về cơ bản có nghĩa là "làm điều này khi nhấp vào". Tuy nhiên, những gì đang diễn ra dưới mui xe là một vòng xử lý tin nhắn. Windows sẽ gửi tin nhắn đến ứng dụng khi người dùng nhấp vào nút và vòng xử lý tin nhắn trong ứng dụng sẽ chạy trình xử lý sự kiện thích hợp.

Ví dụ: nếu bạn sử dụng các sự kiện trong C #, bạn có thể thực hiện việc này mà không cần vòng lặp thông báo, nhưng hạn chế là bạn phải khai báo sự kiện trước thời hạn, vì vậy bạn không thể viết một whencâu lệnh nghệ thuật theo dõi bất kỳ loại nào tiểu bang. Bạn phải chờ đợi một sự kiện cụ thể.

Để có được hành vi này trong Kiến trúc Von Neumann, bạn phải chạy một số loại vòng lặp vô hạn để kiểm tra tất cả các điều kiện mỗi lần thông qua vòng lặp chạy mã thích hợp nếu thích hợp. Trong nội bộ bạn chỉ cần có một danh sách lớn if/ thenhoặc switchbáo cáo. Hầu hết các ứng dụng máy tính để bàn và lập trình viên web sẽ nôn mửa nếu họ thấy một cấu trúc như vậy, nó thực sự chỉ ngon miệng nếu bạn bọc nó trong một loại đường cú pháp như mô hình sự kiện Windows (mặc dù đó là những gì đang diễn ra dưới mui xe).

Mặt khác, nếu bạn nhìn vào lĩnh vực phát triển phần mềm nhúng, giám đốc điều hành thời gian thực hoặc bộ điều khiển công nghiệp, mô hình lập trình này rất phổ biến. Ví dụ: nếu bạn có chương trình thời gian thực, bạn có thể muốn thể hiện:

outputA = input1 && input2

Mã này rất dễ hiểu (vì nó là khai báo). Tuy nhiên, để làm cho nó hoạt động, bạn phải thực hiện nó trong một vòng lặp chặt chẽ. Bạn đánh giá lại outputAmỗi lần qua vòng lặp. Rất nhiều lập trình viên máy tính để bàn hoặc web sẽ không thích điều này vì nó không hiệu quả. Đối với họ, lần duy nhất bạn nên đánh giá lại outputAlà khi nào input1hoặc input2thay đổi. Họ thà nhìn thấy một cái gì đó giống như bạn đang mô tả:

when input1 changes
    evaluateOutputA()

when input2 changes
    evaluateOutputA()

evaluateOutputA()
    outputA = input1 && input2

Bây giờ nếu đây là những gì bạn muốn (và cá nhân tôi không thích ý tưởng này) và mục tiêu của bạn là hiệu quả, thì bạn vẫn phải tự hỏi bộ xử lý đang làm gì dưới mui xe. Rõ ràng vẫn còn một số loại vòng lặp chạy so sánh trạng thái đầu vào với trạng thái đầu vào trước đó mỗi lần và thực thi mã thích hợp mỗi khi thay đổi. Vì vậy, thực sự nó kém hiệu quả và khó đọc hơn và khó bảo trì hơn.

Mặt khác, nếu công việc mà bạn phải làm khi input1thay đổi là đáng kể, thì whenmệnh đề của bạn có thể có ý nghĩa. Trong PLC, loại lệnh này được gọi là "phát hiện cạnh tăng". Nó lưu trạng thái của input1lần cuối cùng qua vòng lặp, so sánh nó với giá trị lần này và thực thi logic nếu trạng thái cuối cùng là sai và trạng thái này là đúng.

Nếu bạn không có Kiến trúc Von Neumann, thì trò chơi sẽ thay đổi. Chẳng hạn, nếu bạn đang lập trình một FPGA trong VHDL , thì khi bạn viết:

outputA = input1 && input2

(... Hoặc bất cứ cú pháp VHDL thích hợp nào) thì thực tế, FPGA thực sự được nối dây như vậy input1và input2được nối với đầu vào của cổng AND và đầu ra của cổng AND được nối với outputA. Vì vậy, không chỉ mã dễ hiểu, nó còn được thực thi song song với tất cả các logic khác và nó hiệu quả.

Khi bạn đang nói về một bộ điều khiển công nghiệp như PLC hoặc PAC, được lập trình bằng một trong năm ngôn ngữ IEC-61131-3, trường hợp điển hình là kiểu sắp xếp này:

1. Đọc đầu vào và lưu trữ trong bộ nhớ
2. Thực hiện chương trình chính
3. Ghi đầu ra từ bộ nhớ vào đầu ra thực tế
4. Chuyển đến bước 1

Điều này được tích hợp vào kiến ​​trúc của hệ thống, do đó, bạn sẽ chỉ cần viết:

outputA = input1 && input2

... Và nó sẽ được thực hiện trong một vòng lặp liên tục.

Ngoài ra còn có các thói quen gián đoạn trong các máy này. Chúng giống như hỗ trợ mức phần cứng cho whentoán tử mà bạn đang nói đến. Các ngắt phần cứng là một phương tiện để thực hiện một số mã trên một sự kiện bên ngoài. Chẳng hạn, khi một card mạng nói rằng nó có dữ liệu đang chờ, bộ xử lý thường phải đọc dữ liệu đó ngay lập tức hoặc bạn sẽ hết dung lượng bộ đệm. Tuy nhiên, đối với số lần bạn cần thực hiện ngắt phần cứng thực sự, tôi nghi ngờ bao gồm một từ khóa ngôn ngữ cho nó là đáng giá. Bạn sẽ bị giới hạn ở các chân đầu vào CPU và có vẻ như bạn muốn kiểm tra trạng thái chương trình bên trong.

Vì vậy, trong một ngôn ngữ truyền thống (không có vòng lặp chặt chẽ chạy vô tận), bạn phải đặt câu hỏi, "khi nào mã đánh giá chạy"?

Nếu bạn viết:

when A do
    launchNukes()

... và giả sử Alà một biểu thức boolean tùy ý, làm thế nào để bạn biết khi nào nên đánh giá lại biểu thức đó? Một triển khai ngây thơ có nghĩa là bạn phải đánh giá lại nó sau mỗi lần ghi bộ nhớ. Bạn có thể nghĩ rằng bạn có thể thu hẹp nó, nhưng hãy xem xét điều này:

when systemTime > actionTime do
    launchNukes()

Lưu ý rằng systemTimeluôn luôn thay đổi (mỗi khi bạn đọc nó, bạn sẽ nhận được một số khác nhau). Điều này có nghĩa là phần điều kiện của tất cả các whenmệnh đề của bạn phải được đánh giá lại liên tục. Điều đó gần như không thể (và chỉ cần xem xét trong giây lát những gì sẽ xảy ra nếu biểu hiện có điều kiện của bạn có tác dụng phụ!)

Phần kết luận

Bạn chỉ có thể có một whencâu lệnh (như bạn đang mô tả) trong một kiến ​​trúc dựa trên một vòng lặp vô hạn chạy chương trình chính, sau đó thực thi các whencâu lệnh nếu các điều kiện chuyển từ false thành true trên vòng lặp này. Mặc dù kiến ​​trúc này là phổ biến trong các thiết bị nhúng và công nghiệp, nhưng nó không phổ biến trong các ngôn ngữ lập trình mục đích chung.

Các ngôn ngữ AspectJ có một mô hình tham-Point, đó là một giải pháp để xử lý một cách chính xác tình huống này.

Điểm tham gia trong AspectJ là một sự kiện động trong chương trình Java xảy ra khi chương trình đang thực thi. Ví dụ các điểm tham gia là: (1) Một phương thức được gọi; (2) Một phương thức được thực thi; (3) Một constructor được gọi; (4) Một constructor được thực thi; (5) Một trường được đặt; hoặc (6) Một trường được truy cập.

Sau đó, bạn có thể tạo tập hợp các điểm tham gia này, được gọi là điểm cắt. Các phím tắt sau đó có thể được nối, bổ sung và giao nhau theo cách lý thuyết tập hợp thông thường. Việc cắt điểm khác có thể được điều chỉnh dựa trên các giá trị / loại biến (ví dụ: "chỉ khi x dương", "chỉ khi giá trị được đặt là một lớp con của loại này") và dựa trên trạng thái của chương trình ("khi phương thức này được gọi, nhưng chỉ khi phương thức khác này nằm trên ngăn xếp của luồng này [có nghĩa là phương thức đó gián tiếp gọi nó] ").

Khi bạn có tất cả các điểm cắt này mô tả các sự kiện trong chương trình, bạn có thể sử dụng AspectJ để tư vấn cho các sự kiện này. Bạn có thể chọn làm một cái gì đó trước khi sự kiện xảy ra ( beforelời khuyên), sau khi sự kiện xảy ra ( afterlời khuyên), hoặc thay vì sự kiện xảy ra ( aroundlời khuyên).

AroundLời khuyên đặc biệt hữu ích cho việc thêm bộ đệm vào các chương trình của bạn: Khi một số phương thức được thực thi, hãy tra cứu trong bảng để xem liệu tính toán tương tự đã được thực hiện chưa và nếu có, hãy sử dụng phiên bản được lưu trong bộ nhớ cache. Với AspectJ, nó rất nhẹ và biểu cảm, bạn có thể thực hiện các thử nghiệm bộ đệm như vậy trên hàng trăm điểm khác nhau trong mã của mình để tìm xem bộ đệm có thêm giá trị hay không.

Nhiều người ngoài lập trình hướng theo khía cạnh tin rằng AOP chủ yếu là về "đăng nhập". Bạn có thể sử dụng AspectJ để xử lý ghi nhật ký và nó hoạt động khá tốt ("ghi vào tệp nhật ký này khi tất cả các phương thức công khai trong gói này được gọi và kết quả / kết quả lỗi của chúng là gì"). Nhưng AspectJ còn có nhiều hơn thế, bao gồm một mẹo thông minh để mô phỏng phạm vi động được gọi là Mô hình lỗ sâu [xem slide 23 và sau đây].

Ngoài AOP, bạn cũng đang nói về lập trình dựa trên sự kiện, bao gồm [như những người khác đã lưu ý] Mẫu Người quan sát. Sự khác biệt giữa các giải pháp là: (1) cách phát hiện điều kiện; (2) trong đó điều kiện được thể hiện; và (3) cách mã thực thi được ràng buộc với sự kiện.

Cách sử dụng Thông báo / Chờ đợi dường như gần với điều này:

Chúng tôi đã đề cập rằng cơ chế chờ / thông báo Java về cơ bản là một cách để giao tiếp giữa các luồng. Tóm lại, ý tưởng như sau:

• một hoặc nhiều luồng ngồi chờ tín hiệu;
• một luồng khác xuất hiện và thông báo cho các luồng chờ (nghĩa là "đánh thức nó / chúng lên" với tín hiệu).

Tùy thuộc vào bối cảnh có một số cấu trúc có thể gần với điều này nhưng bạn thực sự phải làm rõ câu hỏi của bạn.

Ngoài ra còn có một câu lệnh "khi" trong XSLT :

Phần tử được sử dụng để xác định một quá trình hành động dựa trên một loạt các bài kiểm tra. Mỗi bài kiểm tra được thực hiện bên trong một yếu tố. Nếu thử nghiệm thành công, phần tử của phần tử được thực thi. Nếu không có kiểm tra thất bại thì một phần tử có thể được sử dụng để chỉ định một hành động mặc định:

XSLT "khi" là một câu lệnh có điều kiện, giống như một công tắc hơn là nếu. Tuy nhiên, bối cảnh của "khi nào" trong câu hỏi ban đầu không thực sự được làm rõ.

Tôi sử dụng XSLT khá thường xuyên trong CMS Sitecore nơi tôi làm việc để trình bày nội dung để có thể sử dụng nó trong môi trường GUI trong một số trường hợp.

Những gì bạn đang yêu cầu được gọi là lập trình phản ứng .

Đó là một mô hình lập trình trong đó các biến nhận thức được biểu thức mà chúng được gán và bất cứ khi nào một thành phần của biểu thức thay đổi, biến sẽ phản ứng bằng cách đánh giá lại biểu thức, có thể kích hoạt các đánh giá lại tương tự khác xuống chuỗi phụ thuộc .

Thông thường hành vi phản ứng này đạt được thông qua việc sử dụng thông minh mẫu quan sát, trong đó một giá trị phản ứng tự đăng ký như một người lắng nghe một tập hợp các sự kiện kích hoạt việc đánh giá lại giá trị.

Theo hiểu biết tốt nhất của tôi, không tồn tại một ngôn ngữ lập trình hoàn toàn chấp nhận lập trình phản ứng trong cốt lõi của nó, nhưng có rất nhiều thư viện trong nhiều ngôn ngữ cung cấp lợi ích của lập trình phản ứng theo cách này hay cách khác.

Hầu hết các khung ràng buộc dữ liệu có thể được coi là triển khai lập trình phản ứng .

Có một bài viết hay về " Khấu hao mô hình quan sát viên ", có lẽ sẽ giải thích tốt hơn bao giờ hết, lập trình phản ứng là gì và việc triển khai nó sẽ cung cấp các kỹ thuật hiện có như thế nào.

Lisp (và nhiều phương ngữ của nó, bao gồm cả Đề án) có:

(when (> 2 1) 'do-something)

đánh giá do-somethingvà:

(when nil 'other-thing)

đánh giá nilhoặc tương đương của nó.

Tôi biết một loại tuyên bố như vậy chỉ để xử lý lỗi. Ví dụ: BASIC's ON ERROR ...hoặc SQL * PLUSWHENEVER SQLERROR ...

Đối với các điều kiện tùy ý, nó sẽ yêu cầu một trình biên dịch cực kỳ thông minh hoặc một loại vũ lực khá đắt tiền (kiểm tra sau mỗi câu lệnh) để nắm bắt thời điểm chính xác khi các điều kiện trở thành đúng.

Nó là một tính năng của các ngôn ngữ dataflow như ngôn ngữ mô tả phần cứng (Verilog và VHDL).

Ngoài ra, tôi có thể nghĩ về Ada và cơ chế xử lý ngoại lệ của nó: Một trình xử lý ngoại lệ được kích hoạt whenmột số ngoại lệ được nêu ra.

Có vẻ như bạn đang tìm kiếm các biến điều kiện , những thứ cho phép các luồng ngủ cho đến khi một số vị ngữ trở thành đúng.

Boost cụ họ cho C ++, các Apache xách tay Runtime cụ họ cho C. Trong Common Lisp bạn muốn sử dụng bordeaux-thread's make-condition-variable.

Nếu bạn coi Drools là một ngôn ngữ, thì có.

Một ví dụ:

rule "Rule 08 - Debit"
when
    AccountingPeriod( $start : start, $end : end )
    $cashflow : AllocatedCashflow( $account : account, $date : date <= $end, $amount : amount, type==TypedCashflow.DEBIT )
    not AccountingPeriod( start < $start)
then 
    $account.setBalance($account.getBalance()-$amount);
    retract($cashflow);
end

Perl 6 có thể xử lý tín hiệu theo cách trực tiếp bằng cách sử dụng tap:

signal(SIGINT).tap: {
    note "Took { now - INIT now } seconds.";
    exit;
}

for 0, 1, *+* ... * {
    sleep 0.5;
    .say;
}

trong khi Powershell có thể xử lý nó bằng vòng lặp chạy với khối try / cuối cùng:

$Start_Time = (Get-date).second
Write-Host "Type CTRL-C to Terminate..."
$n = 1
Try
{
    While($true)
    {
        Write-Host $n
        $n ++
        Start-Sleep -m 500
    }
}
Finally
{
    $End_Time = (Get-date).second
    $Time_Diff = $End_Time - $Start_Time
    Write-Host "Total time in seconds"$Time_Diff
}

như có thể mong đợi bằng cách sử dụng trap:

package require Expect

proc sigint_handler {} {
    puts "elapsed time: [expr {[clock seconds] - $::start_time}] seconds"
    set ::looping false
}

trap sigint_handler SIGINT

set start_time [clock seconds]
set n 0
set looping true
while {$looping} {
    puts [incr n]
    after 500
}

Người giới thiệu

• Xử lý tín hiệu - Mã Rosetta

• Bảng quyết định - Mã Rosetta

Đã có một thời gian dài kể từ khi tôi nhìn vào những thứ này, vì vậy tôi cũng có thể bị nhầm lẫn.

Khi tôi nhớ lại, cả PL / I và BASIC đều có câu lệnh "BẬT". Trong PL / I, khái niệm này là "TRÊN DO". Trong BASIC, đó là "BẬT", trong đó câu lệnh thường là GOSUB. Trong cả hai ngôn ngữ, bất cứ khi nào điều kiện được chỉ định trở thành đúng, các câu lệnh liên quan sẽ được thực thi.

Bạn sẽ không muốn làm điều này ngày hôm nay. Trình biên dịch về cơ bản phải thực hiện một loạt công việc, để tìm ra nơi / khi điều kiện có thể trở thành đúng, vì vậy nó có thể tạo ra một bài kiểm tra tại thời điểm đó. Khi bạn ở trong trình xử lý có liên quan, bạn không thực sự biết bạn đến từ đâu, vì vậy bạn phải tìm hiểu điều gì đã xảy ra để đưa bạn đến đó và có lẽ bạn không muốn quay lại nơi bạn đến.

Bạn có thể xem ngôn ngữ OPS5 . Các chương trình của nó được viết như một tập hợp các điều kiện. Khi một điều kiện được đáp ứng, hành động tương ứng được thực hiện. Các hành động có thể sửa đổi trạng thái, có thể gây ra các điều kiện khác được đáp ứng. Mặc dù nó không sử dụng whentừ khóa, nhưng về cơ bản, nó hoạt động bằng cách thực hiện các hành động "khi" một điều kiện được đáp ứng. Từ đây :

Một chương trình OPS5 bao gồm một phần khai báo trong đó các cấu trúc dữ liệu cơ bản được xác định theo sau là một phần sản xuất trong đó các quy tắc để thao tác dữ liệu.

Các chương trình OPS5 thực thi bằng cách khớp các phần tử bộ nhớ làm việc với các quy tắc trong bộ nhớ sản xuất và thực hiện (thực thi) quy tắc chi phối nhất được khớp. Chu trình Ghép-Chọn-Thực thi tiếp tục cho đến khi chương trình tạm dừng rõ ràng hoặc cho đến khi không có quy tắc nào có thể khớp với bộ nhớ làm việc.

Tôi đã phải viết một cuộc phiêu lưu văn bản đơn giản bằng ngôn ngữ này khi tôi ở Đại học vào đầu những năm 90. Điều đó thật thú vị, nhưng tôi không chắc nó hữu ích như thế nào đối với hầu hết các tác vụ trên máy tính để bàn hoặc thiết bị di động. Nó có thể có ý nghĩa trong một môi trường phụ trợ, mặc dù.

Haskell có một. Nhưng nó không phải là một cấu trúc đặc biệt, chỉ là một chức năng khác http://hackage.haskell.org/packages/archive/base/latest/doc/html/Control-Monad.html#v:when

Trong hầu hết các ngôn ngữ OOP, có thể sinh ra một chuỗi bổ sung, lấy điều này làm bối cảnh:

    while (!value)
{
}

//Execute code

Vâng, bạn có thể viết một loạt các chủ đề song song, mỗi trong số các cuộc thăm dò cho điều kiện tương ứng của nó. Tôi cho rằng đó sẽ là một ứng dụng có hiệu suất khá thấp, nhưng nó có thể.