Bu kod parçası var ( bu sorudan alınmıştır ):

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

Onu takip etmeye çalışıyorum ve sanırım sonuna kadar yakın olanlar dışında her şeyi anlıyorum !--pending. Bu bağlamda, bu komut ne yapar?

Düzenleme: Tüm diğer yorumları takdir ediyorum, ancak soru birçok kez cevaplandı. Yine de teşekkürler!

! bir değeri tersine çevirir ve size tam tersi boole verir:

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

--[value] bir sayıdan bir (1) çıkartır ve ardından üzerinde çalışılacak sayıyı döndürür:

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

Bu nedenle, !--pendingbeklemede olanı çıkarır ve sonra doğruluk / falsy değerinin tersini döndürür (ister olmasın 0).

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

Ve evet, ProTip'i takip edin. Bu, diğer programlama dillerinde yaygın bir deyim olabilir, ancak çoğu bildirimsel JavaScript programlama için bu oldukça yabancı görünüyor.

Bu özel bir operatör değil, birbiri ardına 2 standart operatör:

1. Bir önek azalması ( --)
2. Mantıksal değil ( !)

Bu pendingazalır ve sıfır olup olmadığını test eder.

Bazı yanıtlar bu komutun ne yaptığını açıklar , ancak neden bu şekilde yapıldığını açıklamaz.

C dünyasından geliyorum ve gerçekten düşünmeden !--pending"geri sayım pendingve sıfır olup olmadığını kontrol et " olarak okuyorum . Benzer dillerdeki programcıların bilmesi gerektiği bir deyimdir.

İşlev readdir, toplu olarak "girişler" olarak adlandıracağım dosya ve alt dizinlerin bir listesini almak için kullanır .

Değişken pending, bunlardan kaç tanesinin işleneceğini takip eder. Liste uzunluğu olarak başlar ve her giriş işlenirken sıfıra doğru aşağı doğru sayar.

Bu girişler sıra dışı işlenebilir, bu nedenle basit bir döngü kullanmak yerine geri sayım yapmak gerekir. Ne zaman bütün kayıtlar işlendikten geri arama doneBu gerçeğin orijinal arayan bildirmek için çağrılır.

İlk çağrıda , bir değer döndürmek istediğimiz için değil, sadece işlevin o noktada yürütmeyi durdurmasını istediğimiz için doneeklenir return. returnAlternatifi bırakmak ve koymak için daha temiz bir kod olurdu else.

Bu bir steno.

! değil".

-- bir değeri azaltır.

Dolayısıyla !--, bir değerin azaltılmasının sonucunu reddetmekten elde edilen değerin yanlış olup olmadığını kontrol eder.

Bunu dene:

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

Birincisi yanlıştır, çünkü x değeri 1 olduğundan, ikincisi doğrudur, çünkü x değeri 0'dır.

Yan not: !x--önce x'in yanlış olup olmadığını kontrol eder ve sonra azaltır.

!JavaScript DEĞİL işleci

--bir azaltma öncesi operatörüdür. Yani,

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

if(!--pending)

anlamına geliyor

if(0 == --pending)

anlamına geliyor

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

Bu, yerinde olmayan ön azaltıcı tarafından takip edilen operatör değildir.

Yani pending, 1 değerine sahip bir tam sayı olsaydı :

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

Sadece bir azalır pendingve mantıksal tamamlayıcısını (olumsuzlama) alır. 0'dan farklı herhangi bir sayının mantıksal tamamlayıcısı, false0 için true.

açıklama

Bu 2 operatör, a !ve a--

!--x 

Yani, --x'i 1 azaltır, o zaman !x şimdi 0 (veya NaN ...) ise true değerini, değilse false değerini döndürür. Bu deyimi "x değerini azaltıyoruz ve bu sıfır yaparsa ..." gibi bir şey okuyabilirsiniz.

Daha okunabilir hale getirmek istiyorsanız, şunları yapabilirsiniz:

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

Denemek:

/* 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 (Kodu Deneyin)

Buradaki asıl sorun, iki operatör !ile arasındaki boşluk olmaması --.

İnsanların neden !operatörlerinden sonra bir boşluk kullanamayacağınızı neden kafalarına aldıklarını bilmiyorum . Bence bu, sağduyu yerine mekanik boşluk kurallarının katı bir şekilde uygulanmasından kaynaklanıyor. Gördüğüm hemen hemen her kodlama standardı, tekli operatörlerden sonra boşlukları yasaklıyor, ama neden?

Bu alana açıkça ihtiyaç duyduğunuz bir durum olsaydı , bu bir tane.

Şu kod parçasını düşünün:

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

Sadece edilir !ve --birlikte püre, o var (çok onlara karşı çarptı. Neyin neye bağlı olduğunu söylemek zor değil.

Biraz daha fazla boşluk kodu çok daha net hale getirir:

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

Elbette, "parenlerde boşluk yok" ve "tekli bir operatörden sonra boşluk yok" gibi mekanik kurallara alışkınsanız, bu biraz yabancı görünebilir.

Ancak ekstra boşlukların nasıl ififade ve ifadenin çeşitli bölümlerini nasıl ayırdığına ve ayırdığına bakın : Sahip oldunuz --pending, bu yüzden --açıkça kendi operatörü ve yakından bağlı pending. (Azalan pendingve azalan sonucu döndürür.) O zaman ondan !ayrıldınız, bu yüzden açıkça ayrı bir operatör, sonucu reddediyor. Sonunda, bir ifade yapmak için tüm ifadeyi aldınız if(ve )çevreliyorsunuz if.

Ve evet, aralarında boşluk kaldırıldı ifve (çünkü ( aittir için if. Bu (, (!--orijinalde olduğu gibi bir tür sözdiziminin bir parçası değildir (, ififadenin sözdiziminin if parçası ise .

Buradaki boşluk , bazı mekanik kodlama standartlarına uymak yerine anlamı iletmeye hizmet eder .