typeof! == không xác định rõ ràng so với!

Tôi thường thấy mã JavaScript kiểm tra các tham số không xác định, v.v ... theo cách này:

if (typeof input !== "undefined") {
    // do stuff
}

Điều này có vẻ lãng phí, vì nó liên quan đến cả tra cứu kiểu và so sánh chuỗi, không đề cập đến tính dài dòng của nó. Nó cần thiết bởi vì undefinedcó thể được đổi tên, mặc dù.

Câu hỏi của tôi là:
Làm thế nào mã đó tốt hơn so với phương pháp này:

if (null != input) {
    // do stuff
}

Theo tôi biết, bạn không thể xác định lại null, vì vậy nó sẽ không bị phá vỡ bất ngờ. Và, do sự ép buộc kiểu của !=toán tử, điều này kiểm tra cả hai undefinedvà null... thường chính xác những gì bạn muốn (ví dụ: đối với các tham số chức năng tùy chọn).

Tuy nhiên, hình thức này dường như không phổ biến và thậm chí nó còn khiến cho JSLint la mắng bạn vì đã sử dụng !=toán tử độc ác .

Tại sao điều này được coi là phong cách xấu?

typeof an toàn hơn vì nó cho phép định danh chưa bao giờ được khai báo trước đó:

if(typeof neverDeclared === "undefined") // no errors

if(neverDeclared === null) // throws ReferenceError: neverDeclared is not defined

Nếu biến được khai báo (với vartừ khóa, như một đối số hàm hoặc là biến toàn cục), tôi nghĩ cách tốt nhất để làm điều đó là:

if (my_variable === undefined)

jQuery làm điều đó, vì vậy nó đủ tốt cho tôi :-)

Nếu không, bạn sẽ phải sử dụng typeofđể tránh a ReferenceError.

Nếu bạn dự kiến ​​không xác định được xác định lại, bạn có thể bọc mã của mình như thế này:

(function(undefined){
    // undefined is now what it's supposed to be
})();

Hoặc có được nó thông qua các voidnhà điều hành:

const undefined = void 0;
// also safe

cách tốt:

if(typeof neverDeclared == "undefined") //no errors

Nhưng cách tốt nhất là kiểm tra qua:

if(typeof neverDeclared === typeof undefined) //also no errors and no strings

Bạn không nên thực sự lo lắng về việc không xác định được đổi tên. Nếu ai đó đổi tên không xác định, bạn sẽ gặp nhiều rắc rối hơn chỉ một vài nếu kiểm tra không thành công. Nếu bạn thực sự muốn bảo vệ mã của mình, hãy bọc nó trong IFFE (biểu thức hàm được gọi ngay lập tức) như thế này:

(function($, Backbone, _, undefined) {
    //undefined is undefined here.
})(jQuery, Backbone, _);

Nếu bạn đang làm việc với các biến toàn cục (đã sai) trong môi trường trình duyệt, tôi sẽ kiểm tra xem không xác định như thế này:

if(window.neverDefined === undefined) {
    //Code works
}

Vì các biến toàn cục là một phần của đối tượng cửa sổ, bạn chỉ cần kiểm tra lại không xác định thay vì truyền vào chuỗi và so sánh chuỗi.

Trên hết, tại sao các biến của bạn không được xác định? Tôi đã thấy rất nhiều mã nơi họ kiểm tra sự tồn tại của biến và thực hiện một số hành động dựa trên đó. Chưa một lần tôi thấy cách tiếp cận này là chính xác.

Nếu bạn thực sự lo lắng về việc không xác định được xác định lại, bạn có thể bảo vệ chống lại điều này bằng một số phương thức trợ giúp như thế này:

function is_undefined(value) {
   var undefined_check; // instantiate a new variable which gets initialized to the real undefined value
   return value === undefined_check;
}

Điều này hoạt động bởi vì khi ai đó viết undefined = "foo" , anh ta chỉ cho phép tên undefined tham chiếu đến một giá trị mới, nhưng anh ta không thay đổi giá trị thực tế của undefined.

Bạn cũng có thể sử dụng toán tử void để lấy giá trị không xác định:

if (input !== void 0) {
    // do stuff    
}

(Và vâng, như đã lưu ý trong một câu trả lời khác, điều này sẽ gây ra lỗi nếu biến không được khai báo, nhưng trường hợp này thường có thể được loại trừ bằng cách kiểm tra mã hoặc bằng cách tái cấu trúc mã, ví dụ như sử dụng window.input !== void 0để kiểm tra các biến toàn cục hoặc thêm var input.)

Tôi thực sự đã đi qua nếu (typeof input !== 'undefined')trong kịch bản này, nơi nó được sử dụng để cung cấp các tham số chức năng mặc định:

function greet(name, greeting) {
  name = (typeof name !== 'undefined') ?  name : 'Student';
  greeting = (typeof greeting !== 'undefined') ?  greeting : 'Welcome';

  return `${greeting} ${name}!`;
}

greet(); // Welcome Student!
greet('James'); // Welcome James!
greet('Richard', 'Howdy'); // Howdy Richard!

ES6 cung cấp các cách mới để giới thiệu các tham số chức năng mặc định theo cách này:

function greet(name = 'Student', greeting = 'Welcome') {
  return `${greeting} ${name}!`;
}

greet(); // Welcome Student!
greet('James'); // Welcome James!
greet('Richard', 'Howdy'); // Howdy Richard!

Điều này ít dài dòng và sạch sẽ hơn so với tùy chọn đầu tiên.

if (input == undefined) { ... }

hoạt động tốt Tất nhiên đó không phải là một nullso sánh, nhưng tôi thường thấy rằng nếu tôi cần phân biệt giữa undefinedvànull , tôi thực sự cần phải phân biệt giữa undefinedvà chỉ bất kỳ giá trị sai, vì vậy

else if (input) { ... }

Phải không.

Nếu một chương trình xác định lại undefined nó thực sự là bản lĩnh.

Lý do duy nhất tôi có thể nghĩ đến là vì khả năng tương thích IE4, nó không hiểu undefinedtừ khóa (thật ra không phải là từ khóa), nhưng tất nhiên giá trị có thể là undefined , vì vậy bạn phải có điều này:

var undefined;

và so sánh ở trên sẽ hoạt động tốt.

Trong ví dụ thứ hai của bạn, có lẽ bạn cần dấu ngoặc đơn để làm cho lint hạnh phúc?