Tôi có cần sử dụng var trong javascript không

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]

6 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]

7 có phạm vi chức năng (nó khai báo một biến có thể nhìn thấy trong toàn bộ chức năng) mặc dù có vẻ như nó có 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]

7 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]

9 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]

0, 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]

1, 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]

2, 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]

6 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]

9. 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]

7

(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 các vấn đề củ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.

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ộ

Mozilla Developer Network đư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]

7 không hoạt động như dự định. Ví dụ của họ là một ví dụ thực tế đặt ____260 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]

7 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]

62 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]

63 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]

6 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]

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

Tất cả chúng ta đều bắt đầu từ đâu đó. Tôi đã học JavaScript khai báo biến với 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]

7. Nó đơn giản và hiệu quả, nhưng tôi đã thay đổi

Nếu bạn viết mã 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]

4, bạn cần dừng lại. Chà, tôi sẽ thành thật mà nói, bạn không cần phải làm vậy, nhưng bạn nên

Chúng ta thường nghĩ về ngôn ngữ lập trình như một bộ quy tắc khắc trong đá. Thực tế là một ngôn ngữ lập trình - giống như bất kỳ ngôn ngữ nói nào - không ngừng phát triển

Bây giờ tôi sử dụng các 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]

9 và

const myFunction = (x,y) => {
  // Do stuff
}myFunction(1,2)

0 để khai báo tất cả các biến của mình trong JavaScript và bạn cũng vậy

Hãy tìm hiểu cách thức và lý do

Khai báo hằng đúng

Một biến, theo tên, xác định một giá trị thay đổi. Mặc dù không nhất thiết có gì sai khi khai báo và không chạm vào một biến, nhưng nếu chúng ta đang cố gắng viết mã có ý nghĩa ngữ nghĩa thì chúng ta nên phân biệt giữa biến và hằng

Hằng đối lập với biến, giá trị đã khai báo không thay đổi. Trong lịch sử, để định nghĩa một hằng số, chúng ta sử dụng tất cả các chữ in hoa, giống như màu sắc tươi sáng trên một con vật độc hại

Thay vì dựa vào quy ước, việc giới thiệu 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]

9 cho chúng ta một tùy chọn rõ ràng để khai báo điều không thay đổi

Để sử dụng 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]

9, chỉ cần hoán đổi nó vớ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]

7 và bây giờ giá trị đó không thể sửa đổi được

// the old way
// var sales_tax = 0.06;// the new way
const sales_tax = 0.06;sales_tax = 0.08; // "TypeError: Assignment to constant variable.

Việc thực hiện đơn giản, lý do đơn giản. 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]

9 là điều dễ hiểu. Nhưng khi nào điều này là thích hợp?

Các tỷ lệ số như thuế suất hoặc chuyển đổi giữa các đơn vị là những lựa chọn dễ dàng. Một nơi khác bạn sẽ thấy

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 đang được sử dụng là khai báo các hàm bằng cách sử dụng ký hiệu mũi tên

________số 8

Bây giờ chức năng của bạn không thể bị ghi đè

Sửa lỗi Quirky Scope của JavaScript

JavaScript bị thiếu sự rõ ràng về phạm vi thường dẫn đến sự thất vọng khi phát triển và khắc phục sự cố. Dưới đây là tóm tắt về các điểm kỳ lạ trong phạm vi JS

• có thể 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]
  

  7 hai lần với một biến (khai báo lại)
• các biến cấp cao nhất là toàn cục theo mặc định (đối tượng toàn cầu)
• các biến có thể được sử dụng trước khi được khai báo (hoisting)
• các biến trong các vòng lặp được sử dụng lại cùng một tham chiếu (bao đóng)

Sử dụng

const myFunction = (x,y) => {
  // Do stuff
}myFunction(1,2)

0 làm rõ và giải quyết nhiều điều kỳ lạ này. Hãy xem xét kỹ hơn

khai báo lại

Cái này đơn giản, bạn không thể khai báo lại một biến đã được tạo bằng

const myFunction = (x,y) => {
  // Do stuff
}myFunction(1,2)

0

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

đối tượng toàn cầu

Ở cấp cao nhất, các biến được khai báo bằ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]

7 được thêm vào đối tượng toàn cầu dưới dạng thuộc tính trong khi các biến

const myFunction = (x,y) => {
  // Do stuff
}myFunction(1,2)

0 thì khô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

cẩu

Các biến được xác định bằng

const myFunction = (x,y) => {
  // Do stuff
}myFunction(1,2)

0 chỉ có thể truy cập được bên trong phạm vi khối của chúng 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]

7 được nâng lên cấp hàm

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]

7

đóng cửa

Cái này khó hiểu nếu nó là một khái niệm mới, nhưng bao đóng là một hàm tham chiếu đến một biến tự do

Khi chúng ta có một bao đóng với 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]

7, tham chiếu sẽ được ghi nhớ, điều này có thể gây rắc rối khi bên trong một vòng lặp mà biến đó thay đổ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]

8

Sử dụng

const myFunction = (x,y) => {
  // Do stuff
}myFunction(1,2)

0, một tham chiếu mới được tạo mỗi lầ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]

0

Cuối cùng, ngay cả khi bạn không hiểu 100% về những lý do này và lý do tại sao chúng hoạt động theo cách chúng làm, thì việc chuyển sang

const myFunction = (x,y) => {
  // Do stuff
}myFunction(1,2)

0 sẽ dẫn đến mã rõ ràng hơn, hoạt động nhất quán và sẽ dễ dàng khắc phục sự cố/bảo trì hơn

Một lời cảnh báo

Mặc dù

const myFunction = (x,y) => {
  // Do stuff
}myFunction(1,2)

0 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]

9 nên thay thế hiệu quả 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]

7, nhưng cuộc sống không phải lúc nào cũng đơn giản như vậy. Vì những từ khóa này đã được giới thiệu trong ECMAScript 2015 (ES6), nếu nền tảng bạn làm việc không cho phép nó thì bạn không gặp may. Ngoài ra, bạn sẽ muốn đảm bảo rằng bạn thực hiện các bước để đảm bảo mã của bạn hoạt động trên các trình duyệt của đối tượng mục tiêu của bạn

Bạn vẫn thấy mình đang 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]

39 chứ?

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

Var có phải là tùy chọn trong JavaScript không?

Chúng ta có thể khai báo biến không có var trong JavaScript không?