Eu tenho esse pedaço de código (retirado desta pergunta ):

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

Estou tentando segui-lo e acho que entendo tudo, exceto no final, onde diz !--pending . Nesse contexto, o que esse comando faz?

Edit: Agradeço todos os comentários, mas a pergunta foi respondida muitas vezes. Obrigado mesmo assim!

! inverte um valor e fornece o booleano oposto:

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

--[value] subtrai um (1) de um número e, em seguida, retorna esse número a ser trabalhado:

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

Portanto, !--pendingsubtrai um de pendente e retorna o oposto de seu valor de verdade / falsidade (seja ou não 0).

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

E sim, siga a ProTip. Esse pode ser um idioma comum em outras linguagens de programação, mas para a maior parte da programação declarativa de JavaScript isso parece bastante estranho.

Não é um operador especial, são dois operadores padrão, um após o outro:

1. Um decremento de prefixo ( --)
2. Um não lógico ( !)

Isso faz pendingcom que seja diminuído e testado para ver se é zero.

Várias respostas descrevem o que esse comando faz, mas não o porquê de ser feito dessa maneira aqui.

Eu venho do mundo C e leio !--pendingcomo "faça uma contagem regressiva pendinge verifique se é zero" sem realmente pensar nisso. É um idioma que eu acho que os programadores em linguagens semelhantes deveriam conhecer.

A função usa readdir para obter uma lista de arquivos e subdiretórios, que eu chamarei coletivamente de "entradas".

A variável pendingmonitora quantos deles ainda precisam ser processados. Começa como o comprimento da lista e conta para baixo em direção a zero à medida que cada entrada é processada.

Essas entradas podem ser processadas fora de ordem, e é por isso que é necessário fazer uma contagem regressiva em vez de apenas usar um loop simples. Quando todas as entradas foram processadas, o retorno de chamada doneé chamado para notificar o chamador original desse fato.

Na primeira chamada, o to doneé anexado return, não porque queremos retornar um valor, mas simplesmente para fazer com que a função pare de ser executada nesse ponto. Teria sido um código mais limpo descartar o returne colocar a alternativa em um else.

É uma taquigrafia.

! não é".

-- diminui um valor.

Portanto, !--verifica se o valor obtido ao negar o resultado da diminuição de um valor é falso.

Tente o seguinte:

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

O primeiro é falso, já que o valor de x é 1, o segundo é verdadeiro, pois o valor de x é 0.

Nota lateral: !x--verificaria primeiro se x é falso e depois o diminuiria.

!é o operador JavaScript NOT

--é um operador de pré-decremento. Assim,

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

if(!--pending)

significa

if(0 == --pending)

significa

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

É o operador not seguido pelo pré-decrementador no local.

Então, se pendingera um número inteiro com um valor de 1:

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

Apenas diminui pendingem um e obtém seu complemento lógico (negação). O complemento lógico de qualquer número diferente de 0 é false, para 0 é true.

Explicação

São 2 operadores, um !e um--

!--x 

Portanto, --diminui x por 1, então !retorna true se x agora é 0 (ou NaN ...), false se não for. Você pode ler esse idioma algo como "decrementamos xe se isso o torna zero ..."

Se você quiser torná-lo mais legível, você pode:

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

Experimente:

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

O verdadeiro problema aqui é a falta de espaço entre os dois operadores !e --.

Não sei por que as pessoas pensam que você nunca pode usar um espaço depois do !operador. Eu acho que vem da aplicação rígida de regras de espaços em branco mecânicos em vez do senso comum. Praticamente todos os padrões de codificação que eu vi proíbem os espaços depois de todos os operadores unários, mas por quê?

Se houve um caso em que você claramente precisa desse espaço, esse é um.

Considere este pedaço de código:

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

Não são apenas !e --misturados, você tem que( bater contra eles também. Não é de admirar que seja difícil dizer o que está conectado ao que.

Um pouco mais de espaço em branco torna o código muito mais claro:

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

Claro, se você está acostumado a regras mecânicas como "sem espaço dentro de parênteses" e "sem espaço após um operador unário", isso pode parecer um pouco estranho.

Mas observe como o espaço em branco extra agrupa e separa as várias partes da ifdeclaração e da expressão: você tem --pending, portanto esse --é claramente o seu próprio operador e está intimamente ligado pending. (Ele decrementa pendinge retorna o resultado decrementado.) Depois, você !separa isso e, portanto, é obviamente um operador distinto, negando o resultado. Finalmente, você tem if(e )envolve toda a expressão para torná-la uma ifdeclaração.

E sim, removi o espaço entre ife (, porque ( pertence ao arquivoif . Isso (não faz parte de algum tipo de (!--sintaxe, como parece estar no original, a (parte if da sintaxe da ifprópria declaração.

O espaço em branco aqui serve para comunicar o significado , em vez de seguir algum padrão de codificação mecânica.