那么为什么 javascript 编译器/解释器不可能只阻止我们目前称为“阻塞”的语句？

因为并发控制。我们希望它们被阻塞，这样（在 JavaScript 的单线程性质中）我们可以避免在我们仍在执行时改变我们函数状态的竞争条件。我们不能有一个解释器在任何任意语句/表达式上暂停当前函数的执行并在程序的某些不同部分恢复。

例子：

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);

JavaScript 运行时中没有任何东西会抢先暂停给定任务的执行，允许其他一些代码执行一段时间，然后恢复原始任务

为什么不？

为了简单和安全，请参见上文。（而且，对于历史课：这就是它刚刚完成的方式）

然而，这不再是事实。随着ES6发电机，还有就是一些可以让你明确暂停当前的执行函数发生器：该yield关键字。

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

生成器 [... 不要...] 导致代码像上面的同步代码一样简单易懂。

但他们做到了！在那篇文章中甚至是正确的：

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

为什么不？没有原因，只是没有完成。

而在 2017 年，它已经在ES2017 中完成：async函数可以用于await等待，非阻塞，以获得Promise的结果。如果getSomething返回一个promise（注意await）并且如果这是在一个async函数中，您可以像这样编写代码：

try 
{
    var foo = await getSomething();
    var bar = doSomething(foo);  
    console.log(bar); 
} 
catch (error) 
{
    console.error(error);
}

（我假设你只是打算getSomething异步，但他们都可以。）

实时示例（需要最新的浏览器，如最近的 Chrome）：

function getSomething() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (Math.random() < 0.5) {
                reject(new Error("failed"));
            } else {
                resolve(Math.floor(Math.random() * 100));
            }
        }, 200);
    });
}
function doSomething(x) {
    return x * 2;
}
(async () => {
    try 
    {
        var foo = await getSomething();
        console.log("foo:", foo);
        var bar = doSomething(foo);  
        console.log("bar:", bar); 
    } 
    catch (error) 
    {
        console.error(error);
    }
})();

The first promise fails half the time, so click Run repeatedly to see both failure and success.

您已使用 NodeJS 标记了您的问题。如果您将 Node API 包装在Promise 中（例如，使用promisify），您可以编写漂亮的、直接的、外观同步的异步运行代码。

因为 Javascript 解释器是单线程的，事件驱动的。这就是最初的语言是如何开发的。

你不能做，"use noblock"因为在那个阶段没有其他工作可以发生。这意味着您的 UI 不会更新。您无法响应来自用户的鼠标或其他输入事件。您无法重绘屏幕。没有什么。

所以你想知道为什么吗？因为 javascript 会导致显示发生变化。如果您能够同时执行这两项操作，那么您的代码和显示就会遇到所有这些可怕的竞争条件。你可能认为你已经在屏幕上移动了一些东西，但它没有绘制，或者它绘制并且你在它绘制之后移动它，现在它必须再次绘制，等等。这种异步性质允许，对于执行中的任何给定事件堆栈具有已知的良好状态 - 在执行此操作时不会修改正在使用的数据。

这并不是说你想要的东西不存在，以某种形式存在。

该async库允许你做这样的事情你parallel的想法（其中包括）。

Generators/async/wait 将允许您编写看起来像您想要的代码（尽管它本质上是异步的）。

尽管您在这里提出了错误的主张 - 人类并不擅长编写异步代码。

其他答案谈到了多线程和并行性引入的问题。但是，我想直接解决您的答案。

为什么不？（例如，“为什么不能有？”......我对历史课不感兴趣）

绝对没有理由。ECMAScript - JavaScript 规范没有说明并发性，它没有指定代码运行的顺序，它根本没有指定事件循环或事件，也没有指定任何关于阻塞或不阻塞的内容。

并发在 JavaScript 中的工作方式是由它的宿主环境定义的——例如在浏览器中是 DOM，而 DOM 指定了事件循环的语义。“异步”函数之类setTimeout的只是 DOM 的关注点，而不是 JavaScript 语言的关注点。

此外，没有什么说 JavaScript 运行时必须运行单线程等等。如果您有顺序代码，则指定了执行顺序，但没有什么能阻止任何人将 JavaScript 语言嵌入多线程环境中。