Programming languages 有没有一种语言，一旦条件语句变为假，它就会从中脱离出来？

我以为我以前遇到过这个问题，但我记不起它是什么时候或什么语言了。 基本上，如果我在C#中有以下内容：

在C#中，当

someCondition

发生变化时，这将从if语句的主体中中断，这意味着

//DO other

仅在

someCondition

未发生变化时才会得到处理

是否有一种语言能够自动执行内部if语句检查/继续，即能够编写：

someCondition = true
if(someCondition)
{
    // Do Something
    if(anotherCond){
        someCondition = false;
    }
    // Do Something Else
}

与前一个相同的行为显然，在每种语言中都有多种方法可以实现这种行为，我感兴趣的是，是否有一种语言在设计上具有这种功能

---

编辑：减少示例，希望人们能够看到发生了什么，当某些条件发生变化时（即if语句开始时所依赖的条件，我们应该中断剩余的if语句。我不是在寻找用C#或任何特定语言实现这一点的方法，而是寻找一种自动实现这一点的语言。

您可以使用do..while循环：

        do
        {

        } while (truth == true);

---

如果我理解正确的话！

您可以使用do..while循环：

        do
        {

        } while (truth == true);

---

如果我理解正确的话！

如果你把一大堆if/else语句分解成简洁的小方法来测试拼图的每一个小部分，你就可以依赖编译器的短路布尔运算了

---

我不确定这是否有帮助，因为你的例子是一个很大的含糊不清的例子。你不会说你是否在做任何处理或只是一堆检查。不管怎样，把代码分解成更小的方法可能会帮你解决问题。

如果你把一大堆if/else语句分解成简洁的小方法来测试拼图的每一小块，你可以依靠编译器进行短路布尔运算

---

我不确定这是否有帮助，因为您的示例非常模糊。您不会说您是否正在进行任何处理或只是一系列检查。无论哪种方式，将代码分解为较小的方法都可能会帮助您解决问题。

您说的虽然是真的，但实际上是真的。我认为无论使用何种语言，您的循环都将无限运行。假设true将是一个真实的条件…我会说只需在其中一个if块中设置退出条件。您的问题有点难以理解。而且继续是不必要的。

您说的虽然为true…但实际上为true。我认为无论使用何种语言，您的循环都将无限运行。假设true将是一个真实的条件…我将你可以说只在其中一个if块中设置退出条件。你的问题有点难理解。继续也没有必要。

你可以在C中创建一个属性，在你设置的任何条件下抛出一个异常，也就是

truth=true

。异常将从循环中爆发到你捕获的任何地方

C#中的一个例子：

---

您可以在C#中创建一个属性，该属性在您设置的任何条件下都会抛出异常，即aka

truth=true

。该异常将从循环中中断到您捕获的任何位置

C#中的一个例子：

---

我想你可以用C来模拟你想要的东西，就像这样：

void ExecuteWhile（函数条件，
我真是太可恶了，
IEnumerable executeWhileFalse）
{
if（条件（））
{
foreach（ExecuteWhiletTrue中的操作）
{
动作（）；
如果（！条件（））
返回；
}
}
其他的
{
foreach（executeWhileFalse中的操作）
{
动作（）；
if（条件（））
返回；
}
}
}

然后按如下方式使用：

truth = true;
while (true) // loop forever
{
    ExecuteWhile( () => truth,
        new List<Action> { () => { /* do something that might set truth to false*/},
                           () => { /* do something else*/}},
        new List<Action> { () => { /* do something that might set truth to true*/},
                           () => { /* do something else*/}});
}

真理=真理；
while（true）//永远循环
{
ExecuteWhile（（）=>真相，
新列表{（）=>{/*执行一些可能将真值设置为假的操作*/}，
（）=>{/*做点别的*/}，
新列表{（）=>{/*做一些可能会将真值设为真的事情*/}，
（）=>{/*做点别的*/}）；
}

---

回答你的问题：不，我认为没有一种语言将此作为内置功能。

我认为你可以在C中模拟你想要的东西，就像这样：

void ExecuteWhile（函数条件，
我真是太可恶了，
IEnumerable executeWhileFalse）
{
if（条件（））
{
foreach（ExecuteWhiletTrue中的操作）
{
动作（）；
如果（！条件（））
返回；
}
}
其他的
{
foreach（executeWhileFalse中的操作）
{
动作（）；
if（条件（））
返回；
}
}
}

然后按如下方式使用：

truth = true;
while (true) // loop forever
{
    ExecuteWhile( () => truth,
        new List<Action> { () => { /* do something that might set truth to false*/},
                           () => { /* do something else*/}},
        new List<Action> { () => { /* do something that might set truth to true*/},
                           () => { /* do something else*/}});
}

真理=真理；
while（true）//永远循环
{
ExecuteWhile（（）=>真相，
新列表{（）=>{/*执行一些可能将真值设置为假的操作*/}，
（）=>{/*做点别的*/}，
新列表{（）=>{/*做一些可能会将真值设为真的事情*/}，
（）=>{/*做点别的*/}）；
}

---

回答您的问题：不，我认为没有一种语言将此作为内置功能。

据我所知，需要以下内容：

if (cond) {
    A;
    B;
    C;
}

其行为应与以下文字相同：

if (cond) {
   A;
   if (cond) {
       B;
       if (cond) {
           C
       }
   }
}

嗯，这将是一个愚蠢的特性，除了INTERCAL之外，不可能在任何语言中实现。 我为什么这么想

好吧，假设有人想要重构代码并将

B；C

移动到一个子例程

if (cond) {
    A;
    BC();
}

subroutine BC() { B;C }

根据我们的特点，该块的含义与之前相同：

if (cond) {
    A;
    if (cond) BC();
}

但是我们的子程序呢？语言设计器有两种选择：

• 将调用

  BC（）

  视为原子调用，即在子例程中 在语句

  C

  之前未检查条件

  cond

  。这意味着 这样一个简单的重构

  if (cond) {
      A;
      if (cond) BC();
  }