Tôi có đoạn mã này (lấy từ câu hỏi này ):

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

Tôi đang cố gắng theo dõi nó, và tôi nghĩ rằng tôi hiểu tất cả mọi thứ ngoại trừ gần cuối nơi nó nói !--pending. Trong bối cảnh này, lệnh đó làm gì?

Chỉnh sửa: Tôi đánh giá cao tất cả các ý kiến ​​thêm, nhưng câu hỏi đã được trả lời nhiều lần. Dù sao cũng cảm ơn bạn!

! đảo ngược một giá trị và cung cấp cho bạn boolean ngược lại:

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

--[value] trừ một (1) từ một số và sau đó trả về số đó sẽ được làm việc với:

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

Vì vậy, !--pendingtrừ đi một trong số đó đang chờ xử lý, và sau đó trả về giá trị ngược lại với giá trị trung thực / giả của nó (cho dù nó có hay không 0).

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

Và vâng, làm theo ProTip. Đây có thể là một thành ngữ phổ biến trong các ngôn ngữ lập trình khác, nhưng đối với hầu hết lập trình JavaScript khai báo, điều này trông khá xa lạ.

Đó không phải là một toán tử đặc biệt, lần lượt là 2 toán tử tiêu chuẩn:

1. Một tiền tố giảm ( --)
2. Một logic không ( !)

Điều này gây ra pendingsự suy giảm và sau đó được kiểm tra xem nó có bằng không.

Một số câu trả lời mô tả những gì lệnh này làm, nhưng không phải tại sao nó được thực hiện theo cách đó ở đây.

Tôi đến từ thế giới C và tôi đọc !--pendinglà "đếm ngược pendingvà kiểm tra xem nó có bằng không" mà không thực sự nghĩ về nó. Đó là một thành ngữ mà tôi nghĩ rằng các lập trình viên trong các ngôn ngữ tương tự nên biết.

Hàm này sử dụng readdirđể lấy danh sách các tệp và thư mục con mà tôi sẽ gọi chung là "mục".

Biến pendingtheo dõi số lượng còn lại sẽ được xử lý. Nó bắt đầu bằng độ dài của danh sách và đếm xuống 0 khi mỗi mục được xử lý.

Các mục này có thể được xử lý theo thứ tự, đó là lý do tại sao cần phải đếm ngược thay vì chỉ sử dụng một vòng lặp đơn giản. Khi tất cả các mục đã được xử lý, cuộc gọi lại doneđược gọi để thông báo cho người gọi ban đầu về thực tế này.

Trong cuộc gọi đầu tiên doneđược chuẩn bị trước return, không phải vì chúng tôi muốn trả về một giá trị, mà chỉ đơn giản là làm cho hàm dừng thực thi tại thời điểm đó. Nó sẽ là mã sạch hơn để bỏ returnvà đặt thay thế trong một else.

Đó là một tốc ký.

! không phải".

-- giảm giá trị

Vì vậy, !--kiểm tra nếu giá trị thu được từ việc phủ định kết quả giảm giá trị là sai.

Thử cái này:

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

Đầu tiên là sai, vì giá trị của x là 1, thứ hai là đúng, vì giá trị của x là 0.

Lưu ý bên: !x--sẽ kiểm tra nếu x là sai trước, và sau đó giảm nó.

!là toán tử JavaScript KHÔNG

--là một toán tử giảm trước. Vì thế,

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

if(!--pending)

có nghĩa

if(0 == --pending)

có nghĩa

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

Đó không phải là toán tử theo sau bởi bộ khử trước tại chỗ.

Vì vậy, nếu pendinglà một số nguyên có giá trị 1:

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

Nó chỉ giảm đi pendingmột và có được bổ sung logic (phủ định). Bổ sung logic của bất kỳ số nào khác 0 là false, với 0 là true.

Giải trình

Đây là 2 toán tử, a !và a--

!--x 

Vì vậy, các số --giảm x 1, sau đó !trả về true nếu x bây giờ là 0 (hoặc NaN ...), sai nếu không. Bạn có thể đọc thành ngữ này một cái gì đó như "chúng tôi giảm x và nếu điều đó làm cho nó bằng không ..."

Nếu bạn muốn làm cho nó dễ đọc hơn, bạn có thể:

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

Dùng thử:

/* 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 (Mã thử)

Vấn đề thực sự ở đây là thiếu khoảng trống giữa hai toán tử !và --.

Tôi không biết tại sao mọi người hiểu rằng bạn không bao giờ sử dụng khoảng trắng sau !toán tử. Tôi nghĩ rằng nó xuất phát từ việc áp dụng cứng nhắc các quy tắc khoảng trắng cơ học thay vì lẽ thường. Gần như mọi tiêu chuẩn mã hóa tôi từng thấy đều cấm không gian sau tất cả các toán tử đơn nguyên, nhưng tại sao?

Nếu đã từng có trường hợp bạn rõ ràng cần không gian đó, thì đây là một trường hợp.

Hãy xem xét đoạn mã này:

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

Không chỉ !và bị --nghiền nát với nhau, bạn cũng đã (đâm sầm vào chúng. Không có gì ngạc nhiên khi thật khó để nói những gì được kết nối với những gì.

Một khoảng trắng nhiều hơn làm cho mã rõ ràng hơn nhiều:

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

Chắc chắn, nếu bạn đã quen với các quy tắc cơ học như "không có không gian bên trong parens" và "không có không gian sau một toán tử đơn nguyên", điều này có vẻ hơi xa lạ.

Nhưng hãy nhìn vào cách các nhóm khoảng trắng bổ sung và phân tách các phần khác nhau của ifcâu lệnh và biểu thức: Bạn đã có --pending, vì vậy --rõ ràng là toán tử riêng của nó và được liên kết chặt chẽ pending. (Nó giảm dần pendingvà trả về kết quả giảm dần.) Sau đó, bạn đã !tách ra khỏi đó để rõ ràng đó là một toán tử riêng biệt, phủ nhận kết quả. Cuối cùng, bạn đã có if(và )bao quanh toàn bộ biểu thức để biến nó thành một iftuyên bố.

Và vâng, tôi đã loại bỏ khoảng trống giữa ifvà (, bởi vì ( thuộc về if. Đây (không phải là một phần của một số loại (!--cú pháp vì nó dường như là trong bản gốc, (nếu là một phần của cú pháp của ifchính câu lệnh.

Khoảng trắng ở đây phục vụ để truyền đạt ý nghĩa , thay vì tuân theo một số tiêu chuẩn mã hóa cơ học.