Làm cách nào để xác định xem một biến là 'không xác định' hay 'null'?

Làm thế nào để tôi xác định nếu biến là undefinedhay null?

Mã của tôi là như sau:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  // DO SOMETHING
};

<div id="esd-names">
  <div id="name"></div>
</div>

Nhưng nếu tôi làm điều này, trình thông dịch JavaScript sẽ dừng thực thi.

Bạn có thể sử dụng các phẩm chất của toán tử đẳng thức trừu tượng để làm điều này:

if (variable == null){
    // your code here.
}

Bởi vì null == undefinedlà đúng, mã trên sẽ bắt cả hai nullvà undefined.

Cách tiêu chuẩn để bắt nullvà undefinedđồng thời là:

if (variable == null) {
     // do something 
}

- trong đó tương đương 100% với rõ ràng hơn nhưng ít súc tích hơn:

if (variable === undefined || variable === null) {
     // do something 
}

Khi viết JS chuyên nghiệp, cần phải có sự bình đẳng kiểu===== đó và hành vi của vs được hiểu. Do đó chúng tôi sử dụng ==và chỉ so sánh với null.

Chỉnh sửa lại

Các ý kiến ​​cho thấy việc sử dụng typeofchỉ đơn giản là sai. Có, giải pháp của tôi ở trên sẽ gây ra ReferenceError nếu biến không tồn tại. Đây là một điều tốt. ReferenceError này là mong muốn: nó sẽ giúp bạn tìm ra lỗi của mình và sửa lỗi trước khi bạn gửi mã, giống như lỗi trình biên dịch trong các ngôn ngữ khác. Sử dụng try/ catchnếu bạn đang làm việc với đầu vào mà bạn không có quyền kiểm soát.

Bạn không nên có bất kỳ tham chiếu nào đến các biến không được khai báo trong mã của mình.

Kết hợp các câu trả lời trên, có vẻ như câu trả lời đầy đủ nhất sẽ là:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

Điều này sẽ làm việc cho bất kỳ biến nào không được khai báo hoặc khai báo và được đặt rõ ràng thành null hoặc không xác định. Biểu thức boolean nên ước tính thành false cho bất kỳ biến khai báo nào có giá trị không null thực tế.

if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

if (typeof EmpName != 'undefined' && EmpName) {

sẽ đánh giá là đúng nếu giá trị không:

• vô giá trị

• chưa xác định

• NaN

• chuỗi rỗng ("")

• 0

• sai

attr()Hàm jQuery trả về một chuỗi trống hoặc giá trị thực (và không bao giờ nullhoặc undefined). Lần duy nhất nó trả về undefinedlà khi bộ chọn của bạn không trả về bất kỳ phần tử nào.

Vì vậy, bạn có thể muốn kiểm tra đối với một chuỗi trống. Ngoài ra, vì các chuỗi trống, null và không xác định là false-y, bạn chỉ có thể làm điều này:

if (!EmpName) { //do something }

Tôi đã đến để viết chức năng của riêng tôi cho việc này. JavaScript thật kỳ lạ.

Nó có thể sử dụng trên bất cứ điều gì theo nghĩa đen. (Lưu ý rằng điều này cũng kiểm tra xem biến có chứa bất kỳ giá trị có thể sử dụng nào không . Nhưng vì thông tin này thường cũng cần thiết, tôi nghĩ rằng nó đáng để đăng). Hãy xem xét để lại một ghi chú.

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

Tương thích với TypeScript.

Hàm này sẽ thực hiện chính xác giống như empty()hàm của PHP (xem RETURN VALUES)

Xem xét undefined, null, false, 0, 0.0, "0" {}, []như trống rỗng.

"0.0", NaN, " ", trueĐược coi là không có sản phẩm nào.

Nếu biến bạn muốn kiểm tra là toàn cục, hãy làm

if (window.yourVarName) {
    // Your code here
}

Cách kiểm tra này sẽ không gây ra lỗi ngay cả khi yourVarNamebiến không tồn tại.

Ví dụ: Tôi muốn biết liệu trình duyệt của tôi có hỗ trợ API Lịch sử không

if (window.history) {
    history.back();
}

Cách thức hoạt động:

windowlà một đối tượng chứa tất cả các biến toàn cục làm thuộc tính của nó và trong JavaScript, việc cố gắng truy cập vào một thuộc tính đối tượng không tồn tại là hợp pháp. Nếu historykhông tồn tại thì window.historytrả về undefined. undefinedlà falsey, vì vậy mã trong một if(undefined){}khối sẽ không chạy.

Ngắn nhất và dễ nhất:

if(!EmpName ){
 // DO SOMETHING
}

điều này sẽ đánh giá đúng nếu EmpName là:

• vô giá trị
• chưa xác định
• NaN
• trống
• chuỗi ("")
• 0
• sai

Có lẽ cách ngắn nhất để làm điều này là:

if(EmpName == null) { /* DO SOMETHING */ };

Đây là bằng chứng:

function check(EmpName) {
  if(EmpName == null) { return true; };
  return false;
}

var log = (t,a) => console.log(`${t} -> ${check(a)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" 

Và đây là chi tiết về ==(nguồn ở đây )

THƯỞNG : lý do tại sao ===rõ ràng hơn ==(nhìn vào câu trả lời agc )

Tôi vừa gặp vấn đề này, tức là kiểm tra xem một đối tượng có rỗng không.
Tôi chỉ đơn giản là sử dụng cái này:

if (object) {
    // Your code
}

Ví dụ:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

Vì bạn đang sử dụng jQuery , bạn có thể xác định xem một biến không được xác định hoặc giá trị của nó là null bằng cách sử dụng một hàm duy nhất.

var s; // undefined
jQuery.isEmptyObject(s); // will return true;

s = null; // defined as null
jQuery.isEmptyObject(s); // will return true;

// usage
if(jQuery.isEmptyObject(s)){
    alert('Either variable: s is undefined or its value is null');
}else{
     alert('variable: s has value ' + s);
}

s = 'something'; // defined with some value
jQuery.isEmptyObject(s); // will return false;

Phần tử kiểm tra jQuery không null:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

Trong JavaScript, theo hiểu biết của tôi, chúng ta có thể kiểm tra một biến không xác định, null hoặc rỗng như bên dưới.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Kiểm tra tất cả các điều kiện:

if(variable === undefined || variable === null || variable === ''){
}

Bạn có thể chỉ cần sử dụng những điều sau đây (tôi biết có những cách ngắn hơn để làm điều này, nhưng điều này có thể giúp quan sát trực quan dễ dàng hơn, ít nhất là đối với những người khác đang xem mã).

if (x === null || x === undefined) {
 // Add your response code here, etc.
}

Cách dễ nhất để kiểm tra là:

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

Với giải pháp dưới đây:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

Tôi có thể kiểm tra các mục sau:

• vô giá trị
• chưa xác định
• NaN
• trống
• chuỗi ("")
• 0
• sai

Để kiểm tra xem một biến là null hay không xác định, tôi sử dụng đoạn mã dưới đây.

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

Tôi chạy thử nghiệm này trong bảng điều khiển Chrome. Sử dụng (void 0) bạn có thể kiểm tra không xác định:

var c;
undefined
if (c === void 0) alert();
// output =  undefined
var c = 1;
// output =  undefined
if (c === void 0) alert();
// output =   undefined
// check c value  c
// output =  1
if (c === void 0) alert();
// output =  undefined
c = undefined;
// output =  undefined
if (c === void 0) alert();
// output =   undefined

Hãy nhìn vào điều này,

1.  

   let apple; // Only declare the variable as apple
   alert(apple); // undefined

   Ở trên, biến chỉ được khai báo là apple. Trong trường hợp này, nếu chúng ta gọi phương thức, alertnó sẽ hiển thị không xác định.

2.  

      let apple = null; /* Declare the variable as apple and initialized but the value is null */
      alert(apple); // null

Trong cái thứ hai, nó hiển thị null, vì biến applegiá trị là null.

Vì vậy, bạn có thể kiểm tra xem một giá trị là không xác định hoặc null.

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

Cách tốt nhất:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}

(null == undefined)  // true

(null === undefined) // false

Bởi vì === kiểm tra cả loại và giá trị. Loại của cả hai là khác nhau nhưng giá trị là như nhau.

var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

Việc foo == nullkiểm tra cần thực hiện thủ thuật và giải quyết trường hợp "không xác định HOẶC null" theo cách ngắn nhất. (Không xem xét trường hợp "foo không được khai báo".) Nhưng những người đã từng có 3 bằng (như cách thực hành tốt nhất) có thể không chấp nhận nó. Chỉ cần nhìn vào các quy tắc eqeqeq hoặc triple-bằng trong eslint và tslint ...

Cách tiếp cận rõ ràng, khi chúng tôi đang kiểm tra xem một biến là undefinedhay nullriêng biệt, nên được áp dụng trong trường hợp này và đóng góp của tôi cho chủ đề (27 câu trả lời không phủ định bây giờ!) Là sử dụng void 0như một cách ngắn gọn và an toàn để thực hiện kiểm tra cho undefined.

Sử dụng foo === undefinedkhông an toàn vì không xác định không phải là một từ dành riêng và có thể bị che khuất ( MDN ). Sử dụng typeof === 'undefined'kiểm tra là an toàn, nhưng nếu chúng ta không quan tâm đến trường hợp không được khai báo thì có thể sử dụng phương pháp sau:

if (foo === void 0 || foo === null) { ... }

nếu bạn tạo một hàm để kiểm tra nó:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

Việc gọi typeof null trả về một giá trị của đối tượng, vì giá trị đặc biệt null được coi là một tham chiếu đối tượng trống. Safari thông qua phiên bản 5 và Chrome đến phiên bản 7 có một sự giải quyết trong đó việc gọi kiểu trên một biểu thức thông thường sẽ trả về hàm hàm Cameron trong khi tất cả các trình duyệt khác trả về đối tượng Hồi.

var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

Bạn chỉ có thể sử dụng cái thứ hai: vì nó sẽ kiểm tra cả định nghĩa và khai báo

Tôi vẫn nghĩ cách tốt nhất / an toàn để kiểm tra hai điều kiện này là truyền giá trị thành một chuỗi:

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // Do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // Do something with your code
}

Bạn có thể kiểm tra xem giá trị là không xác định hoặc null bằng cách sử dụng typeof:

if(typeof value == 'undefined'){

if(x==null)là một ý tưởng tồi trong JavaScript. Đánh giá với "=="- nó có thể gây ra một sự ép buộc kiểu không mong muốn và CoffeeScript không thể đọc được, không bao giờ sử dụng "==" hoặc "! =" Trong phán đoán điều kiện!

if(x)sẽ tốt hơn, nhưng hãy cẩn thận với 0 và "" . Nó sẽ được coi là sai , không phải phương thức bằng với "!= null"là đúng .

Xem Thực tiễn tốt nhất về JavaScript .