Tôi có nên ngừng sử dụng var JavaScript không?

Question

Vấn đề là,

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

5 tránh nguồn gây hiểu lầm, đặc biệt. dành cho các lập trình viên với các kỳ vọng được đặt bởi các ngôn ngữ có phạm vi khối. Một

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6 có phạm vi chức năng (nó khai báo một biến hiển thị trong toàn bộ chức năng) mặc dù có vẻ như nó có phạm vi khối

Nội dung chính Show

1. Phạm vi - lý do chính để tránh var
2. Cẩu — không phải lo lắng cho function f(x) { let y = 1; if (x > 0) { let y = 2; // `let` declares a variable in this block } return y; } [f(1), f(-1)] // --> [1, 1] // Start over, but change `let` to `var`. // --> [2, 1] 5
3. Ràng buộc đối tượng toàn cầu
4. khai báo lại. Không tốt với Let

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6 có thể vẫn hữu ích trong trường hợp cực đoan như mã do máy tạo ra, nhưng tôi đang cố gắng hết sức ở đó

(

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

8 cũng mới và có phạm vi khối. Sau

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

9, bạn có thể gán lại cho

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

0, trong khi sau

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

1, bạn không thể gán lại cho

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

0. Điều đó thường tốt hơn vì nó ngăn thứ gì đó vô tình thay đổi từ bên dưới bạn. Nhưng để rõ ràng, bạn vẫn có thể sửa đổi đối tượng

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

1 trừ khi bạn đóng băng nó. )

Trên thực tế, ấn tượng của bạn là phù hợp với ES6. Thông qua

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

5 và

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

8. Ngừng sử dụng

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6

(Trong một màn trình diễn khác của "The Better Parts", Doug nói lý do tại sao

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

5 được thêm vào thay vì sửa.

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6 tạo ra một số kết quả "đáng ngạc nhiên", vì vậy chỉ cần áp dụng

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

5. )

Một ví dụ tiết lộ

đưa ra một ví dụ trong đó

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6 không hoạt động như dự định. Ví dụ của họ là một ví dụ thực tế đặt ____150 trình xử lý trong một trang web. Đây là một trường hợp thử nghiệm nhỏ hơn

var a = [];
(function () {
   'use strict';
   for (let i = 0; i < 5; ++i) { // *** `let` works as expected ***
     a.push( function() {return i;} );
   }
} ());
console.log(a.map( function(f) {return f();} ));
// prints [0, 1, 2, 3, 4]

// Start over, but change `let` to `var`.
// prints [5, 5, 5, 5, 5]

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6 làm chúng tôi vấp ngã vì tất cả các lần lặp lại chia sẻ cùng một biến

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

52 trong phạm vi chức năng, có giá trị

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

53 sau khi vòng lặp kết thúc

Một ví dụ khác

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

5 khai báo các biến trong phạm vi khối.

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6 khiến chúng ta bối rối khi đề cập đến cùng một biến trong toàn hàm

JavaScript là một ngôn ngữ mạnh mẽ vì bạn có thể viết toàn bộ phần mềm mà không cần sử dụng bất kỳ ngôn ngữ lập trình nào khác

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6 từng là một cách khai báo biến trong JavaScript. Tuy nhiên, việc khai báo một biến hoặc đối tượng theo cách này hiện rất hiếm do cơn ác mộng mà nó có thể tạo ra trong dự án JavaScript của bạn

var obj = {} 
// instead let (or const) is used to declare a variable

Bắt đầu với ECMAScript 6, câu lệnh

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

5 đã được giới thiệu

Sau đây là tổng quan ngắn gọn về lý do tại sao

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6 không còn hoặc hiếm khi được sử dụng trong các dự án JavaScript để khai báo biến

Ghi chú. Nếu bạn đã quen thuộc với những cạm bẫy khi sử dụng var, thì bài viết này vẫn có thể là một phần bổ sung hữu ích cho bạn

1. Phạm vi - lý do chính để tránh var

Phạm vi là sự khác biệt chính giữa var và let

Các biến

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6 nằm trong phạm vi thân hàm ngay lập tức (do đó là phạm vi hàm) trong khi các biến

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

5 nằm trong phạm vi khối bao quanh ngay lập tức được biểu thị bằng

function run() {var foo = "Foo";
let bar = "Bar";
console.log(foo, bar); // Foo Bar{
 var moo = "Mooo"
 let baz = "Bazz";
 console.log(moo, baz); // Mooo Bazz
}
console.log(moo); // Mooo
console.log(baz); // ReferenceError}run();

1

Hãy hiểu điều đó có nghĩa là gì thông qua mã

________số 8

Lý do tại sao từ khóa

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

5 được đưa vào ngôn ngữ này là do phạm vi chức năng khó hiểu và là một trong những nguyên nhân chính gây ra lỗi trong JavaScript

2. Cẩu — không phải lo lắng cho function f(x) { let y = 1; if (x > 0) { let y = 2; // `let` declares a variable in this block } return y; } [f(1), f(-1)] // --> [1, 1] // Start over, but change `let` to `var`. // --> [2, 1] 5

Đầu tiên, chúng ta cần tìm hiểu xem cẩu là gì

Các biến có thể truy cập được trong phạm vi kèm theo của chúng ngay cả trước khi chúng được khai báo

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

0

Nhưng không phải lo lắng.

function run() {var foo = "Foo";
let bar = "Bar";
console.log(foo, bar); // Foo Bar{
 var moo = "Mooo"
 let baz = "Bazz";
 console.log(moo, baz); // Mooo Bazz
}
console.log(moo); // Mooo
console.log(baz); // ReferenceError}run();

4 sẽ không để điều đó xảy ra

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

2

3. Ràng buộc đối tượng toàn cầu

Ở cấp cao nhất,

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

5, không giống như

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6, không tạo thuộc tính trên đối tượng toàn cầu

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

3

4. khai báo lại. Không tốt với Let

Ở chế độ nghiêm ngặt,

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

6 sẽ cho phép bạn khai báo lại cùng một biến trong cùng một phạm vi trong khi

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

5 gây ra Lỗi Cú pháp

function f(x) {
    let y = 1;
    if (x > 0) {
        let y = 2;  // `let` declares a variable in this block
    }
    return y;
}
[f(1), f(-1)]  // --> [1, 1]

// Start over, but change `let` to `var`.
// --> [2, 1]

4

Kiểm tra chủ đề thực tế để biết thêm hoặc viết trong các bình luận nếu bạn nghĩ rằng tôi đã bỏ lỡ bất cứ điều gì. Tôi sẽ thêm nó và cập nhật bài viết cho phù hợp

programming javascript

Tôi có nên ngừng sử dụng var JavaScript không?

1. Phạm vi - lý do chính để tránh var

2. Cẩu — không phải lo lắng cho function f(x) { let y = 1; if (x > 0) { let y = 2; // `let` declares a variable in this block } return y; } [f(1), f(-1)] // --> [1, 1] // Start over, but change `let` to `var`. // --> [2, 1] 5

3. Ràng buộc đối tượng toàn cầu

4. khai báo lại. Không tốt với Let

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội