我有这段代码（取自这个问题）：

var walk = function(dir, done) {
    var results = [];

    fs.readdir(dir, function(err, list) {
        if (err)
            return done(err);

        var pending = list.length;

        if (!pending) 
            return done(null, results);

        list.forEach(function(file) {
            file = path.resolve(dir, file);
            fs.stat(file, function(err, stat) {
                if (stat && stat.isDirectory()) {
                    walk(file, function(err, res) {
                        results = results.concat(res);

                        if (!--pending)
                            done(null, results);
                    });
                } else {
                    results.push(file);

                    if (!--pending) 
                        done(null, results);
                }
            });
        });
    });
};

我正在尝试遵循它，并且我认为我理解所有内容，除了它所说的末尾处!--pending。在这种情况下，该命令有什么作用？

编辑：我感谢所有进一步的评论，但问题已得到解答很多次。不管怎么说，还是要谢谢你！

! 反转一个值，并给您相反的布尔值：

!true == false
!false == true
!1 == false
!0 == true

--[value] 从数字中减去一（1），然后返回要使用的数字：

var a = 1, b = 2;
--a == 0
--b == 1

因此，!--pending从未决中减去1，然后返回其true / falsy值的相反值（无论是否为0）。

pending = 2; !--pending == false 
pending = 1; !--pending == true
pending = 0; !--pending == false

是的，请遵循ProTip。在其他编程语言中，这可能是常见的习惯用法，但是对于大多数声明性JavaScript编程而言，这似乎很陌生。

这不是一个特殊的运算符，一个接一个的是两个标准运算符：

1. 前缀递减（--）
2. 逻辑非（!）

这将导致pending递减，然后进行测试以查看其是否为零。

有许多答案描述了此命令的功能，但没有说明为什么在此这样做。

我来自C语言世界，读!--pending为“递减pending并检查是否为零”，而没有真正考虑它。我认为类似语言的程序员应该知道这是一个习惯用法。

该函数用于readdir获取文件和子目录的列表，我将其统称为“条目”。

该变量pending跟踪要处理的剩余数量。它从列表的长度开始，并在处理每个条目时向下计数到零。

这些条目可能会乱序处理，这就是为什么有必要倒数而不是仅使用简单循环的原因。当全部的项目都已经被处理的回调done被调用，通知这个事实原始调用者。

在第一个调用中以done开头return，不是因为我们要返回一个值，而是简单地使函数在那一点上停止执行。删除return并将替代项放入else。

这是简写​​。

! 不是”。

-- 递减值。

因此，请!--检查否定值减结果所获得的值是否为假。

尝试这个：

var x = 2;
console.log(!--x);
console.log(!--x);

第一个为false，因为x的值为1，第二个为true，因为x的值为0。

旁注： !x--首先检查x是否为假，然后将其递减。

!是JavaScript NOT运算符

--是递减运算符。所以，

x = 1;
if (!x) // false
if (!--x) // becomes 0 and then uses the NOT operator,
          // which makes the condition to be true

if(!--pending)

手段

if(0 == --pending)

手段

pending = pending - 1;
if(0 == pending)

它是非运算符，之后是就地预减数器。

因此，如果pending是一个值为1的整数：

val = 1;
--val; // val is 0 here
!val // evaluates to true

它仅减少pending一个，并获得其逻辑补（负）。不同于0的任何数字的逻辑补码为false，对于0则为true。

说明

这是2个运算子，a !和a--

!--x 

因此，将--x减1，然后!如果x现在为0（或NaN ...），则返回true，否则返回false。您可能会读到这个成语，例如“我们将x递减，如果它减为零...”

如果您想使其更具可读性，可以：

var x = 1
x = x - 1   
if(!x){ //=> true
    console.log("I understand `!--` now!") 
}
x //=> 0

试试看：

/* This is an example of the above, you can read this, but it is not needed for !-- */function interactive(a){$("span.code").keydown(function(e){if(13==(e.keyCode||e.which)){var t=$(this);t.clone().html("code").insertAfter(t.next().next()).show().focus().after(template.clone().removeClass("result-template").show()).next().after("<br>"),interactive(),e.preventDefault()}}).keyup(function(e){13!=(e.keyCode||e.which)&&run()})}var template=$(".result-template").hide(),code=$("span.code");code.attr("contenteditable","true").each(function(e,t){template.clone().removeClass("result-template").insertAfter(t)}),interactive(),$.fn.reduce=[].reduce;function run(){var b=!1,context={};$("span.code").each(function(){var a=$(this),res=a.next().show().removeClass("error");try{with(context)res.html(b?"":"  //=> "+eval(a.text()))}catch(e){b=e,res.html("  Error: "+b.message).addClass("error")}})};run();

/* This is an example of the above, you can read this, but it is not needed for !-- */span.result.error{display:block;color:red}.code{min-width:10px}body{font-family:Helvetica,sans-serif}

<!-- This is an example of the above, you can read this, but it is not needed for `!--` --><span class="result result-template"> //=> unknown </span> <h2>Edit This Code:</h2><code><span class="code">x = 1</span><br><span class="code">!--x</span><br><span class="code"> x </span><br></code> <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

小提琴（试用代码）

真正的问题在于，两个运算符!和之间没有空格--。

我不知道为什么人们会想到您永远不能在!操作员之后使用空格。我认为它来自机械空白规则的严格应用而非常识。我所见过的几乎所有编码标准都在所有一元运算符之后禁止使用空格，但是为什么呢？

如果曾经有明显的需求，那就是一个。

考虑一下这段代码：

if (!--pending)
    done(null, results);

不仅是!和--一起捣碎，你已经得到了(撞着他们。难怪很难分辨什么与什么相关。

更多的空格使代码更清晰：

if( ! --pending )
    done( null, results );

当然，如果您习惯于使用机械规则，例如“括号内没有空格”和“一元运算符之后没有空格”，那么这似乎有点陌生。

但是，请看一下额外的空白如何将if语句和表达式的各个部分进行分组和分隔：您已经了解了--pending，所以--显然是它自己的运算符，并且与紧密相关pending。（它递减pending并返回递减的结果。）然后，您将其与之!分开，因此它显然是一个独特的运算符，对结果进行求反。最后，你得if(和)周围的整体表现，使它的if声明。

是的，我删除之间的空间if和(，因为( 所属的if。这(不是某种(!--语法的一部分，因为它似乎是原始(语法（如果是if语句本身的语法的if部分）。

这里的空格用于传达含义，而不是遵循某些机械编码标准。