Mam ten fragment kodu (wzięty z tego pytania ):

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

Staram się podążać za tym i myślę, że rozumiem wszystko, z wyjątkiem końca, gdzie jest napisane !--pending. W tym kontekście, co robi to polecenie?

Edycja: Doceniam wszystkie dalsze komentarze, ale na pytanie udzielono odpowiedzi wiele razy. W każdym razie dzięki!

! odwraca wartość i daje przeciwną wartość logiczną:

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

--[value] odejmuje jeden (1) od liczby, a następnie zwraca tę liczbę do pracy z:

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

Tak, !--pendingodejmuje jeden z toku, a następnie powraca przeciwieństwo jego truthy / wartość falsy (czy nie jest 0).

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

I tak, postępuj zgodnie z ProTip. Może to być powszechny idiom w innych językach programowania, ale w przypadku większości deklaratywnych programów JavaScript wygląda to zupełnie obco.

To nie jest operator specjalny, to 2 standardowe operatory jeden po drugim:

1. Dekrementacja przedrostka ( --)
2. Logiczne not ( !)

Powoduje pendingto zmniejszenie wartości, a następnie sprawdzenie, czy jest równa zero.

Szereg odpowiedzi opisuje, co robi to polecenie, ale nie wyjaśnia , dlaczego tak się tutaj dzieje.

Pochodzę ze świata C i czytam !--pendingjako „odliczaj pendingi sprawdzam, czy wynosi zero”, nie myśląc o tym. Jest to idiom, który moim zdaniem powinien znać programiści w podobnych językach.

Ta funkcja służy readdirdo uzyskania listy plików i podkatalogów, które zbiorczo nazywam „wpisami”.

Zmienna pendingśledzi, ile z nich pozostało do przetworzenia. Zaczyna się od długości listy i odlicza w dół do zera podczas przetwarzania każdego wpisu.

Wpisy te mogą być przetwarzane poza kolejnością, dlatego konieczne jest odliczanie, a nie zwykła pętla. Po przetworzeniu wszystkich wpisów oddzwanianie donejest wywoływane w celu powiadomienia pierwotnego dzwoniącego o tym fakcie.

W pierwszym wywołaniu donejest poprzedzone znakiem return, nie dlatego, że chcemy zwrócić wartość, ale po prostu, aby funkcja przestała działać w tym momencie. Byłoby czystszym kodem upuścić returni umieścić alternatywę w else.

To jest skrót.

! nie jest".

-- zmniejsza wartość.

!--Sprawdza więc , czy wartość uzyskana z zanegowania wyniku zmniejszenia wartości jest fałszywa.

Spróbuj tego:

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

Pierwszy jest fałszywy, ponieważ wartość x wynosi 1, drugi jest prawdziwy, ponieważ wartość x wynosi 0.

Uwaga dodatkowa: !x--najpierw sprawdza, czy x jest fałszem, a następnie go zmniejsza.

!jest operatorem JavaScript NOT

--jest operatorem przedsprzedaży. Więc,

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

if(!--pending)

znaczy

if(0 == --pending)

znaczy

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

To nie operator, a za nim miejscowy środek do dekrementacji.

Więc jeśli pendingbył liczbą całkowitą o wartości 1:

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

Po prostu maleje pendingo jeden i uzyskuje logiczne uzupełnienie (negację). Logicznym uzupełnieniem dowolnej liczby różnej od 0 jest false, dla 0 jest true.

Wyjaśnienie

To jest 2 operatorów, a !i a--

!--x 

Zatem --zmniejszenie x o 1, a następnie !zwraca true, jeśli x jest teraz 0 (lub NaN ...), false, jeśli nie jest. Możesz przeczytać ten idiom coś w stylu „zmniejszamy x, a jeśli to czyni zero…”

Jeśli chcesz, aby był bardziej czytelny, możesz:

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

Wypróbuj to:

/* 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 (kod wypróbowania)

Prawdziwym problemem jest tutaj brak odstępu między dwoma operatorami !i --.

Nie wiem, dlaczego ludzie mają w głowie, że nigdy nie można użyć spacji za !operatorem. Myślę, że wynika to ze sztywnego stosowania mechanicznych reguł białych znaków zamiast zdrowego rozsądku. Prawie każdy standard kodowania, który widziałem, zabrania spacji po wszystkich jednostkowych operatorach, ale dlaczego?

Jeśli zdarzały się przypadki, w których wyraźnie potrzebujesz tej przestrzeni, jest to jedna sprawa .

Rozważ ten fragment kodu:

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

Nie tylko są !i --zmiksowane razem, masz to( je również przeciwko niemu. Nic dziwnego, że trudno powiedzieć, co jest z tym związane.

Trochę więcej białych znaków sprawia, że ​​kod jest znacznie wyraźniejszy:

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

Jasne, jeśli jesteś przyzwyczajony do reguł mechanicznych, takich jak „brak spacji w parenach” i „brak spacji po jednostkowym operatorze”, może to wydawać się nieco obce.

Ale spójrz, jak dodatkowe białe znaki grupują i oddzielają różne części ifwyrażenia i wyrażenia: Masz --pending, więc --jest to oczywiście jego własny operator i ściśle z nim związany pending. (Zmniejsza pendingi zwraca obniżony wynik.) Następnie zostałeś !oddzielony od tego, więc jest to oczywiście wyraźny operator, negujący wynik. Wreszcie, masz if(i )otaczasz całym wyrażeniem, aby uczynić to ifstwierdzeniem.

I tak, usunąłem spację między ifi (, ponieważ ( należy do if. Nie (jest to część jakiejś (!--składni, ponieważ wydaje się, że jest w oryginale, (jeśli jest częścią składni ifsamej instrukcji.

Biała spacja służy tutaj do przekazywania znaczenia , zamiast przestrzegać jakiegoś standardu kodowania mechanicznego.