У мене є цей фрагмент коду (узятий з цього питання ):

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віднімаємо одне від очікуваного, а потім повертаємо протилежне його значення truthy / falesy (незалежно від того, чи ні 0).

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

І так, дотримуйтесь ProTip. Це може бути поширеною фразою в інших мовах програмування, але для більшості декларативних програм програмування JavaScript це виглядає досить чужо.

Це не спеціальний оператор, це два стандартних оператора один за одним:

1. Декремент префікса ( --)
2. Логічно не ( !)

Це призводить pendingдо зменшення, а потім тестування, щоб перевірити, чи не дорівнює нулю.

У ряді відповідей описано, що ця команда робить, але не чому вона робиться саме так.

Я родом із світу С, і читаю !--pendingяк "відлічуй pendingі перевіряю, чи дорівнює нулю", не думаючи про це. Я вважаю, що програмісти подібними мовами - це ідіома.

Функція використовує readdirдля отримання списку файлів і підкаталогів, які я спільно називатиму "записами".

Змінна pendingвідслідковує, скільки з них залишається обробити. Він починається як довжина списку і відраховується вниз до нуля під час обробки кожного запису.

Ці записи можуть бути оброблені поза порядком, тому необхідно відлік часу, а не просто простий цикл. Коли всі записи були оброблені, doneвикликається зворотний дзвінок , щоб сповістити початкового абонента про цей факт.

У першому дзвінку до done, що передує return, не тому, що ми хочемо повернути значення, а просто для того, щоб функція припинила виконання у цій точці. Було б більш чистим кодом скинути returnта поставити альтернативу в else.

Це стенограма.

! не".

-- зменшення значення.

Тому !--перевіряється, чи значення, отримане в результаті заперечення результату зменшення значення, помилкове.

Спробуйте це:

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

Перше - хибне, оскільки значення х дорівнює 1, друге - істинне, оскільки значення х дорівнює 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 ...), 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>

Fiddle (Спробуйте код)

Справжня проблема тут - відсутність простору між двома операторами !та --.

Я не знаю, чому люди отримують це в голові, що ви ніколи не можете використовувати простір після !оператора. Я думаю, що це походить від жорсткого застосування механічних правил пробілу замість здорового глузду. Майже кожен стандарт кодування, який я бачив, забороняє пробіли після всіх одинакових операторів, але чому?

Якщо колись був випадок, коли вам явно потрібен цей простір, це один.

Розглянемо цей біт коду:

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

Мало того, що вони !і --пюре разом, у вас це є( грюкнули проти них теж. Недарма важко сказати, що з чим пов’язано.

Трохи більше пробілів робить код набагато зрозумілішим:

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

Звичайно, якщо ви звикли до таких механічних правил, як "немає місця всередині паролів" і "немає місця після одинарного оператора", це може здатися чужим.

Але подивіться, як додатковий пробіл групує та розділяє різні частини ifвисловлювання та виразу: Ви отримали --pending, значить, --це явно власний оператор і тісно пов'язаний з ним pending. (Він декрементує pendingі повертає зменшений результат.) Тоді ви !відокремилися від цього, так що це, очевидно, окремий оператор, заперечуючи результат. Нарешті, у вас є if(і )оточення цілого виразу, щоб зробити це ifзаявою.

І так, я видалив простір між ifі (, оскільки ( належить до if. Це (не є частиною (!--синтаксису, як здається, в оригіналі, (якщо є частиною синтаксису самого ifтвердження.

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