作为cowboy says down in the comments here ，我们都想“以类似这样的风格编写 [非阻塞 JavaScript] 异步代码:

 try 
 {
    var foo = getSomething();   // async call that would normally block
    var bar = doSomething(foo);  
    console.log(bar); 
 } 
 catch (error) 
 {
    console.error(error);
 }

”

所以人们想出了解决这个问题的办法，比如

• 回调库(例如async)
• promises
• event patterns
• streamline
• domains和
• generators .

但是这些都不会导致代码像上面的同步样式代码那样简单易懂。

那么，为什么 javascript 编译器/解释器不可能只是不阻塞我们目前称为“阻塞”的语句？ 那么，为什么 javascript 编译器/解释器无法处理上面的同步语法，就像我们以异步样式编写它一样？”

例如，在处理上面的 getSomething() 时，编译器/解释器可能只是说“这个语句是对 [文件系统/网络资源/...] 的调用，所以我会记下来听那个电话的回应，同时继续处理我的事件循环中的任何内容”。当调用返回时，可以继续执行 doSomething()。

您仍将保持流行 JavaScript 运行时环境的所有基本功能

• 单线程
• 事件循环
• “异步”处理的阻塞操作(I/O、网络、等待计时器)

这将是对语法的简单调整，这将允许解释器在检测到异步操作时暂停对任何给定代码位的执行，而不是需要回调，代码只是从异步调用后的行继续当电话返回时。

作为Jeremy说

there is nothing in the JavaScript runtime that will preemptively pause the execution of a given task, permit some other code to execute for a while, and then resume the original task

为什么不呢？ (比如，“为什么不能有？”……我对历史课不感兴趣)

为什么开发人员必须关心语句是否阻塞？计算机用于自动化人类不擅长的事情(例如编写非阻塞代码)。

你也许可以用

• 像"use noblock";这样的语句(有点像"use strict";)来开启这个“模式”整页代码。编辑:“使用 noblock”；是一个糟糕的选择，并且误导了一些回答者我试图完全改变常见 JavaScript 运行时的性质。像 'use syncsyntax'; 这样的描述可能更好。
• 某种parallel(fn, fn, ...); 语句允许您在"use syncsyntax" 中并行运行事物；模式——例如允许同时启动多个异步事件
• 编辑:一个简单的同步式语法 wait()，将在 "use syncsyntax" 中代替 setTimeout() 使用;模式

编辑:

作为例子，而不是写(标准回调版本)

function fnInsertDB(myString, fnNextTask) {
  fnDAL('insert into tbl (field) values (' + myString + ');', function(recordID) {
    fnNextTask(recordID);
  });
}

fnInsertDB('stuff', fnDeleteDB);

你可以写

'use syncsyntax';

function fnInsertDB(myString) {
  return fnDAL('insert into tbl (field) values (' + myString ');');  // returns recordID
}

var recordID = fnInsertDB('stuff'); 
fnDeleteDB(recordID);

syncsyntax 版本的处理方式与标准版本完全相同，但更容易理解程序员的意图(只要您了解 syncsyntax 暂停按照讨论的方式执行此代码)。

最佳答案

So why isn't possible for javascript compilers/interpreters to just NOT block on the statements we currently know as "blocking"?

因为concurrency control .我们希望它们阻塞，这样(在 JavaScript 的单线程特性中)我们就不会受到 race conditions 的影响。在我们仍在执行函数的同时改变函数的状态。我们不能让解释器在任何任意语句/表达式处暂停当前函数的执行，然后继续执行程序的某些不同部分。

例子:

function Bank() {
    this.savings = 0;
}
Bank.prototype.transfer = function(howMuch) {
    var savings = this.savings;
    this.savings = savings + +howMuch(); // we expect `howMuch()` to be blocking
}

同步代码:

var bank = new Bank();
setTimeout(function() {
    bank.transfer(prompt); // Enter 5
    alert(bank.savings);   // 5
}, 0);
setTimeout(function() {
    bank.transfer(prompt); // Enter 3
    alert(bank.savings);   // 8
}, 100);

异步、任意非阻塞代码:

function guiPrompt() {
    "use noblock";
    // open form
    // wait for user input
    // close form
    return input;
}
var bank = new Bank(); 
setTimeout(function() {
    bank.transfer(guiPrompt); // Enter 5
    alert(bank.savings);      // 5
}, 0);
setTimeout(function() {
    bank.transfer(guiPrompt); // Enter 3
    alert(bank.savings);      // 3 // WTF?!
}, 100);

参见 https://glyph.twistedmatrix.com/2014/02/unyielding.html以获得更长的(与语言无关的)解释。

there is nothing in the JavaScript runtime that will preemptively pause the execution of a given task, permit some other code to execute for a while, and then resume the original task

为什么不呢？

为了简单和安全，见上文。 (而且，对于历史课:事情就是这样完成的)

然而，这不再是事实。对于 ES6 生成器， 可以让您显式暂停当前 function 生成器的执行:yield 关键字。

随着语言的发展，ES7 还计划了 async 和 await 关键字。

generators [… don't …] lead to code as simple and easy to understand as the sync code above.

但是他们有!在那篇文章中甚至是正确的:

suspend(function* () {
//              ^ "use noblock" - this "function" doesn't run continuously
    try {
        var foo = yield getSomething();
//                ^^^^^ async call that does not block the thread
        var bar = doSomething(foo);  
        console.log(bar); 
    } catch (error) {
        console.error(error);
    }
})

这里还有一篇关于这个主题的非常好的文章:http://howtonode.org/generators-vs-fibers

关于javascript - 为什么流行的 JavaScript 运行时不能处理看起来同步的异步脚本？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/25446353/