J'ai ce morceau de code (tiré de cette question ):

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

J'essaie de le suivre, et je pense que je comprends tout, sauf vers la fin où il est dit !--pending. Dans ce contexte, que fait cette commande?

Edit: J'apprécie tous les autres commentaires, mais la question a été répondue à plusieurs reprises. Merci quand même!

! inverse une valeur et vous donne le booléen opposé:

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

--[value] soustrait un (1) d'un nombre, puis renvoie ce nombre avec lequel travailler:

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

Donc, !--pendingsoustrait un de l'attente, puis retourne le contraire de sa valeur de vérité / fausse (que ce soit ou non 0).

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

Et oui, suivez le ProTip. Cela peut être un idiome courant dans d'autres langages de programmation, mais pour la plupart des programmes JavaScript déclaratifs, cela semble assez étranger.

Ce n'est pas un opérateur spécial, c'est 2 opérateurs standard l'un après l'autre:

1. Un préfixe décrément ( --)
2. Un pas logique ( !)

Cela provoque pendingune décrémentation, puis un test pour voir s'il est nul.

Un certain nombre de réponses décrivent ce que fait cette commande, mais pas pourquoi elle est effectuée de cette façon ici.

Je viens du monde C, et je lis !--pendingcomme "compte à rebourspending et vérifie si c'est zéro" sans vraiment y penser. C'est un idiome que je pense que les programmeurs dans des langages similaires devraient connaître.

La fonction utilise readdirpour obtenir une liste de fichiers et de sous-répertoires, que j'appellerai collectivement «entrées».

La variable pendinggarde la trace du nombre de ceux qui restent à traiter. Il commence comme la longueur de la liste et compte vers le bas vers zéro lorsque chaque entrée est traitée.

Ces entrées peuvent être traitées dans le désordre, c'est pourquoi il est nécessaire de décompter plutôt que de simplement utiliser une simple boucle. Lorsque toutes les entrées ont été traitées, le rappel doneest appelé pour informer l'appelant d'origine de ce fait.

Dans le premier appel à doneest précédé de return, non pas parce que nous voulons retourner une valeur, mais simplement pour arrêter l'exécution de la fonction à ce point. Il aurait été préférable de supprimer le code returnet de mettre l'alternative dans un else.

C'est un raccourci.

! n'est pas".

-- décrémente une valeur.

!--Vérifie donc si la valeur obtenue en annulant le résultat de la décrémentation d'une valeur est fausse.

Essaye ça:

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

La première est fausse, car la valeur de x est 1, la seconde est vraie, car la valeur de x est 0.

Remarque: !x--vérifierait d'abord si x est faux, puis le décrémenterait.

!est l' opérateur JavaScript NOT

--est un opérateur de pré-décrémentation. Donc,

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

if(!--pending)

veux dire

if(0 == --pending)

veux dire

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

C'est l'opérateur not suivi du pré-décrémenteur en place.

Donc, si pendingétait un entier avec une valeur de 1:

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

Il diminue simplement pendingde un et obtient son complément logique (négation). Le complément logique de tout nombre différent de 0 est false, pour 0, il l'est true.

Explication

Il s'agit de 2 opérateurs, a !et a--

!--x 

Ainsi, le --décrémente x de 1, puis le !retourne vrai si x est maintenant 0 (ou NaN ...), faux s'il ne l'est pas. Vous pourriez lire cet idiome quelque chose comme "nous décrémentons x et si cela le rend nul ..."

Si vous souhaitez le rendre plus lisible, vous pouvez:

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

Essaye le:

/* 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 (Try Out Code)

Le vrai problème ici est le manque d'espace entre les deux opérateurs !et --.

Je ne sais pas pourquoi les gens pensent que vous ne pouvez jamais utiliser un espace après l' !opérateur. Je pense que cela vient d'une application rigide des règles mécaniques des espaces blancs au lieu du bon sens. Presque toutes les normes de codage que j'ai vues interdisent les espaces après tous les opérateurs unaires, mais pourquoi?

S'il y a jamais eu un cas où vous avez clairement besoin de cet espace, celui-ci en est un.

Considérez ce morceau de code:

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

Non seulement sont !et --purée ensemble, vous avez que( a claqué contre eux aussi. Pas étonnant qu'il soit difficile de dire ce qui est connecté à quoi.

Un peu plus d'espace rend le code beaucoup plus clair:

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

Bien sûr, si vous êtes habitué aux règles mécaniques comme "pas d'espace à l'intérieur des parens" et "pas d'espace après un opérateur unaire", cela peut sembler un peu étranger.

Mais regardez comment les espaces blancs supplémentaires regroupent et séparent les différentes parties de l' ifinstruction et de l'expression: vous avez --pending, donc --c'est clairement son propre opérateur et est étroitement lié à pending. (Il décrémente pendinget renvoie le résultat décrémenté.) Ensuite, vous avez le !séparé de cela, c'est donc évidemment un opérateur distinct, annulant le résultat. Enfin, vous avez if(et )entourez toute l'expression pour en faire une ifdéclaration.

Et oui, j'ai supprimé l'espace entre ifet (, car le ( appartient au if. Cela (ne fait pas partie d'une sorte de (!--syntaxe, comme il semble être dans l'original, la (partie if de la syntaxe de l' ifinstruction elle-même.

L'espace blanc ici sert à communiquer la signification , au lieu de suivre une norme de codage mécanique.