Ho questo pezzo di codice (tratto da questa domanda ):

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

Sto provando a seguirlo, e penso di capire tutto tranne che verso la fine dove dice !--pending. In questo contesto, cosa fa quel comando?

Modifica: apprezzo tutti gli ulteriori commenti, ma alla domanda è stata data risposta molte volte. Grazie comunque!

! inverte un valore e ti dà il valore booleano opposto:

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

--[value] sottrae uno (1) da un numero, quindi restituisce quel numero con cui lavorare:

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

Così, !--pending sottrae una persona in sospeso, quindi restituisce l'opposto del suo valore di verità / falsità (indipendentemente dal fatto che sia 0).

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

E sì, segui il suggerimento. Questo può essere un linguaggio comune in altri linguaggi di programmazione, ma per la maggior parte della programmazione JavaScript dichiarativa sembra abbastanza alieno.

Non è un operatore speciale, sono 2 operatori standard uno dopo l'altro:

1. Un decremento prefisso (-- )
2. Un non logico ( !)

Questo provoca pendingun decremento e quindi il test per vedere se è zero.

Un numero di risposte descrive cosa fa questo comando, ma non perché qui viene fatto in questo modo.

Vengo dal mondo C e leggo !--pendingcome "conto alla rovesciapending e controlla se è zero" senza pensarci davvero. È un linguaggio che penso che i programmatori in lingue simili dovrebbero conoscere.

La funzione utilizza readdir per ottenere un elenco di file e sottodirectory, che chiamerò collettivamente "voci".

La variabile pendingtiene traccia di quanti di questi rimangono da elaborare. Inizia come la lunghezza dell'elenco e conta verso il basso verso zero man mano che ogni voce viene elaborata.

Queste voci possono essere elaborate in modo anomalo, motivo per cui è necessario eseguire il conto alla rovescia anziché semplicemente utilizzare un semplice ciclo. Quando tutte le voci sono state elaborate, il callback doneviene chiamato per avvisare il chiamante originale di questo fatto.

Nella prima chiamata a doneviene anteposto return, non perché vogliamo restituire un valore, ma semplicemente per far cessare l'esecuzione della funzione in quel punto. Sarebbe stato un codice più pulito eliminare returne inserire l'alternativa in un else.

È una scorciatoia.

! non è".

-- decrementa un valore.

Quindi !--controlla se il valore ottenuto negando il risultato del decremento di un valore è falso.

Prova questo:

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

Il primo è falso, poiché il valore di x è 1, il secondo è vero, poiché il valore di x è 0.

Nota a margine: !x--verificherebbe prima se x è falso, quindi lo decrementerà.

!è l' operatore JavaScript NOT

--è un operatore pre-decremento. Così,

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

if(!--pending)

si intende

if(0 == --pending)

si intende

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

È l'operatore non seguito dal pre-decrementatore sul posto.

Quindi se pendingfosse un numero intero con un valore di 1:

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

Diminuisce semplicemente pendingdi uno e ottiene il suo complemento logico (negazione). Il complemento logico di qualsiasi numero diverso da 0 è false, per 0 lo è true.

Spiegazione

Sono 2 operatori, a !e a--

!--x 

Quindi, --decrementa x di 1, quindi !restituisce true se x è ora 0 (o NaN ...), false se non lo è. Potresti leggere questo idioma qualcosa del tipo "decrementiamo x e se questo lo rende zero ..."

Se vuoi renderlo più leggibile, puoi:

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

Provalo:

/* 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 (codice di prova)

Il vero problema qui è la mancanza di uno spazio tra i due operatori !e --.

Non so perché la gente si renda conto che non puoi mai usare uno spazio dopo l' !operatore. Penso che provenga dall'applicazione rigida delle regole meccaniche degli spazi bianchi invece del buon senso. Quasi tutti gli standard di codifica che ho visto vietano gli spazi dopo tutti gli operatori unari, ma perché?

Se ci fosse mai un caso in cui hai chiaramente bisogno di quello spazio, questo è uno.

Considera questo bit di codice:

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

Non solo vengono !e --schiacciati insieme, ma li hai anche (colpiti. Non c'è da stupirsi che sia difficile dire cosa sia connesso a cosa.

Un po 'più di spazio bianco rende il codice molto più chiaro:

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

Certo, se sei abituato a regole meccaniche come "nessuno spazio dentro le parentesi" e "nessuno spazio dopo un operatore unario", questo può sembrare un po 'estraneo.

Ma guarda come lo spazio extra in bianco raggruppa e separa le varie parti ifdell'affermazione e dell'espressione: hai --pending, quindi --è chiaramente il suo operatore ed è strettamente legato pending. (Diminuisce pendinge restituisce il risultato decrementato.) Quindi hai !separato da quello quindi è ovviamente un operatore distinto, annullando il risultato. Alla fine, hai if(e )circostante l'intera espressione per renderla una ifdichiarazione.

E sì, ho rimosso lo spazio tra ife (, poiché ( appartiene al if. Questo (non fa parte di alcun tipo di (!--sintassi come sembra essere nell'originale, la (parte if della sintassi ifdell'istruzione stessa.

Lo spazio bianco qui serve a comunicare il significato , invece di seguire alcuni standard di codifica meccanica.