У меня есть этот кусок кода (взят из этого вопроса ):

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вычитает один из ожидающих, а затем возвращает противоположность его истинности / ложные значения (независимо от того, является ли он 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);

Первое ложно, так как значение x равно 1, второе истинно, так как значение x равно 0.

Примечание: !x--сначала проверит, является ли x ложным, а затем уменьшит его.

!оператор JavaScript НЕ

--является оператором перед декрементом. Так,

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)

Это оператор not, за которым следует предварительный декремент на месте.

Так что, если pendingбыло целое число со значением 1:

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

Он просто уменьшается pendingна единицу и получает свое логическое дополнение (отрицание). Логическое дополнение любого числа, отличного от 0 false, для 0 это true.

объяснение

Это 2 оператора, а !и--

!--x 

Таким образом, --x уменьшается на 1, а затем !возвращает true, если x теперь равно 0 (или NaN ...), и 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оператора.

Пробелы здесь служат для передачи смысла , а не следуют некоторому стандарту механического кодирования.