Ich habe diesen Code (aus dieser Frage entnommen ):

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

Ich versuche, ihm zu folgen, und ich glaube, ich verstehe alles, außer gegen Ende, wo es heißt !--pending. Was macht dieser Befehl in diesem Zusammenhang?

Edit: Ich freue mich über alle weiteren Kommentare, aber die Frage wurde schon oft beantwortet. Danke trotzdem!

! Invertiert einen Wert und gibt Ihnen den entgegengesetzten Booleschen Wert:

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

--[value] subtrahiert eins (1) von einer Zahl und gibt dann die Zahl zurück, mit der gearbeitet werden soll:

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

Also, !--pendingsubtrahiert man aus schwebenden und kehrt dann das Gegenteil von seiner truthy / falsy Wert (ob oder nicht es ist 0).

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

Und ja, folgen Sie dem ProTip. Dies mag in anderen Programmiersprachen eine gängige Redewendung sein, aber für die meisten deklarativen JavaScript-Programme sieht dies ziemlich fremd aus.

Das ist kein spezieller Operator, es sind 2 Standardoperatoren nacheinander:

1. Ein Präfixdekrement ( --)
2. Ein logisches nicht ( !)

Dies führt pendingdazu, dass dekrementiert und dann getestet wird , um festzustellen, ob es Null ist.

Eine Reihe von Antworten beschreibt, was dieser Befehl tut, aber nicht, warum er hier so ausgeführt wird.

Ich komme aus der C-Welt und lese !--pendingals "Countdown pendingund überprüfe, ob es Null ist", ohne wirklich darüber nachzudenken. Es ist eine Redewendung, die Programmierer in ähnlichen Sprachen meiner Meinung nach kennen sollten.

Die Funktion verwendet readdir, um eine Liste von Dateien und Unterverzeichnissen zu erhalten, die ich zusammen "Einträge" nennen werde.

Die Variable pendingverfolgt, wie viele davon noch verarbeitet werden müssen. Es beginnt als Länge der Liste und zählt bei jeder Verarbeitung nach unten in Richtung Null.

Diese Einträge können außerhalb der Reihenfolge verarbeitet werden, weshalb ein Countdown erforderlich ist, anstatt nur eine einfache Schleife zu verwenden. Wenn alle Einträge verarbeitet wurden, wird der Rückruf doneaufgerufen, um den ursprünglichen Anrufer über diese Tatsache zu informieren.

Im ersten Aufruf von donewird nicht vorangestellt return, nicht weil wir einen Wert zurückgeben möchten, sondern einfach, damit die Funktion an diesem Punkt nicht mehr ausgeführt wird. Es wäre sauberer gewesen, den Code fallen zu lassen returnund die Alternative in einen zu setzen else.

Es ist eine Abkürzung.

! ist nicht".

-- dekrementiert einen Wert.

!--Überprüft also , ob der Wert, der durch Negieren des Ergebnisses der Dekrementierung eines Werts erhalten wird, falsch ist.

Versuche dies:

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

Der erste ist falsch, da der Wert von x 1 ist, der zweite ist wahr, da der Wert von x 0 ist.

Randnotiz: !x--würde zuerst prüfen, ob x falsch ist, und es dann dekrementieren.

!ist der JavaScript NOT- Operator

--ist ein Operator vor dem Dekrementieren. Damit,

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

if(!--pending)

meint

if(0 == --pending)

meint

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

Es ist der Nicht-Operator, gefolgt vom In-Place-Vordekrementierer.

Wenn also pendingeine Ganzzahl mit dem Wert 1 wäre:

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

Es nimmt lediglich um pendingeins ab und erhält seine logische Ergänzung (Negation). Das logische Komplement einer beliebigen Zahl false, die sich von 0 unterscheidet, ist für 0 true.

Erläuterung

Dies sind 2 Operatoren, a !und a--

!--x 

Also --dekrementiert x um 1, dann !gibt true zurück, wenn x jetzt 0 ist (oder NaN ...), false, wenn dies nicht der Fall ist. Sie könnten diese Redewendung so etwas wie "Wir dekrementieren x und wenn das Null macht ..." lesen.

Wenn Sie es lesbarer machen möchten, können Sie:

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

Versuch es:

/* 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>

Geige (Code ausprobieren)

Das eigentliche Problem hierbei ist das Fehlen eines Leerzeichens zwischen den beiden Operatoren !und --.

Ich weiß nicht, warum die Leute es in ihren Köpfen verstehen, dass man nach dem !Operator niemals ein Leerzeichen verwenden kann . Ich denke, es kommt von der starren Anwendung mechanischer Leerzeichenregeln anstelle des gesunden Menschenverstandes. Fast jeder Codierungsstandard, den ich gesehen habe, verbietet Leerzeichen nach allen unären Operatoren, aber warum?

Wenn es jemals einen Fall gab, in dem Sie diesen Platz eindeutig benötigen , ist dies einer.

Betrachten Sie diesen Code:

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

Nicht nur !und-- püriert, du hast das auch (gegen sie geschlagen. Kein Wunder, dass es schwer zu sagen ist, was mit was verbunden ist.

Ein bisschen mehr Leerzeichen macht den Code viel klarer:

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

Sicher, wenn Sie an mechanische Regeln wie "kein Platz in Parens" und "kein Platz nach einem unären Operator" gewöhnt sind, scheint dies etwas fremd zu sein.

Aber schauen Sie sich an, wie das zusätzliche Leerzeichen die verschiedenen Teile der ifAnweisung und des Ausdrucks gruppiert und trennt : Sie haben --pending, also --ist das eindeutig sein eigener Operator und eng mit ihm verbunden pending. (Es dekrementiert pendingund gibt das dekrementierte Ergebnis zurück.) Dann haben Sie das davon !getrennt, so dass es offensichtlich ein eindeutiger Operator ist, der das Ergebnis negiert. Schließlich haben Sie , if(und )den gesamten Ausdruck umgibt , um es eine machen ifAussage.

Und ja, entfernte ich den Raum zwischen ifund (, weil das ( gehört zu dem if. Dies (ist nicht Teil einer (!--Syntax, wie es im Original zu sein scheint, der (if-Teil der Syntax der ifAnweisung selbst.

Das Leerzeichen dient hier dazu, die Bedeutung zu kommunizieren , anstatt einem mechanischen Codierungsstandard zu folgen.