Tengo este código (tomado de esta pregunta ):

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

Estoy tratando de seguirlo, y creo que entiendo todo, excepto cerca del final donde dice !--pending . En este contexto, ¿qué hace ese comando?

Editar: agradezco todos los comentarios adicionales, pero la pregunta ha sido respondida muchas veces. ¡Gracias de cualquier manera!

! invierte un valor y le da el booleano opuesto:

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

--[value] resta uno (1) de un número y luego devuelve ese número para trabajarlo:

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

Entonces, !--pendingresta uno de pendiente y luego devuelve lo opuesto a su valor de verdad / falsedad (ya sea que sea o no 0).

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

Y sí, sigue la ProTip. Esto puede ser un idioma común en otros lenguajes de programación, pero para la mayoría de la programación declarativa de JavaScript esto parece bastante extraño.

Ese no es un operador especial, son 2 operadores estándar uno tras otro:

1. Una disminución de prefijo ( --)
2. Un no lógico ( !)

Esto hace pendingque se disminuya y luego se pruebe para ver si es cero.

Varias respuestas describen lo que hace este comando, pero no por qué se hace así aquí.

Vengo del mundo C, y leo !--pendingcomo "cuenta atráspending y verifica si es cero" sin pensar realmente en ello. Es un idioma que creo que los programadores en lenguajes similares deberían saber.

La función se utiliza readdirpara obtener una lista de archivos y subdirectorios, que colectivamente llamaré "entradas".

La variable pendingrealiza un seguimiento de cuántos de estos quedan por procesar. Comienza como la longitud de la lista y cuenta hacia abajo hacia cero a medida que se procesa cada entrada.

Estas entradas pueden procesarse fuera de servicio, por lo que es necesario realizar una cuenta regresiva en lugar de simplemente usar un bucle simple. Cuando se han procesado todas las entradas, donese llama a la devolución de llamada para notificar al llamador original de este hecho.

En la primera llamada a donese antepone return, no porque queramos devolver un valor, sino simplemente para que la función deje de ejecutarse en ese punto. Hubiera sido un código más limpio descartar returny poner la alternativa en un else.

Es una taquigrafía.

! no es".

-- disminuye un valor.

Por lo tanto, !--comprueba si el valor obtenido al negar el resultado de disminuir un valor es falso.

Prueba esto:

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

El primero es falso, ya que el valor de x es 1, el segundo es verdadero, ya que el valor de x es 0.

Nota al margen: !x--primero verificaría si x es falso y luego lo disminuiría.

!es el JavaScript NO operador

--es un operador de pre-decremento. Entonces,

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

if(!--pending)

medio

if(0 == --pending)

medio

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

Es el operador no seguido por el pre-decrementador en el lugar.

Entonces, si pendingfuera un entero con un valor de 1:

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

Simplemente disminuye pendingen uno y obtiene su complemento lógico (negación). El complemento lógico de cualquier número diferente de 0 es false, para 0 es true.

Explicación

Esto es 2 operadores, a !y a--

!--x 

Entonces, los --decrementos x por 1, entonces el! devuelve verdadero si x es ahora 0 (o NaN ...), falso si no lo es. Puede leer este modismo algo así como "decrementamos xy si eso lo hace cero ..."

Si desea que sea más legible, puede:

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

Pruébalo:

/* 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 (código de prueba)

El verdadero problema aquí es la falta de espacio entre los dos operadores !y --.

No sé por qué las personas piensan que no se puede usar un espacio después del !operador. Creo que proviene de la aplicación rígida de las reglas mecánicas de espacios en blanco en lugar del sentido común. Casi todos los estándares de codificación que he visto prohíben espacios después de todos los operadores unarios, pero ¿por qué?

Si alguna vez hubo un caso en el que claramente necesita ese espacio, este es uno.

Considere este bit de código:

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

No solo son !y se --mezclan, tienes eso( golpeado contra ellos también. No es de extrañar que sea difícil saber qué está conectado a qué.

Un poco más de espacio en blanco hace que el código sea mucho más claro:

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

Claro, si estás acostumbrado a las reglas mecánicas como "sin espacio dentro de parens" y "sin espacio después de un operador unario", esto puede parecer un poco extraño.

Pero observe cómo el espacio en blanco adicional agrupa y separa las diversas partes de la ifdeclaración y la expresión: lo tiene --pending, por lo --que claramente es su propio operador y está estrechamente vinculado pending. (Disminuye pendingy devuelve el resultado decrementado). Entonces tienes el !separado de eso, por lo que obviamente es un operador distinto, que niega el resultado. Finalmente, tienes if(y )rodea toda la expresión para que sea una ifdeclaración.

Y sí, eliminé el espacio entre ify (, porque ( pertenece al if. Esto (no es parte de algún tipo de (!--sintaxis, ya que parece estar en el original, (si es parte de la sintaxis de la ifdeclaración en sí.

El espacio en blanco aquí sirve para comunicar el significado , en lugar de seguir algún estándar de codificación mecánica.