Có một hàm JavaScript phổ quát nào kiểm tra xem một biến có giá trị không và đảm bảo rằng nó không phải undefinedhay nullkhông? Tôi đã nhận được mã này, nhưng tôi không chắc liệu nó có bao gồm tất cả các trường hợp không:

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}

Bạn chỉ có thể kiểm tra xem biến có truthygiá trị hay không. Điều đó có nghĩa là

if( value ) {
}

sẽ đánh giá để truenếu valuelà không :

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

Danh sách trên thể hiện tất cả các falsygiá trị có thể có trong ECMA- / Javascript. Tìm nó trong đặc điểm kỹ thuật tại ToBooleanphần.

Hơn nữa, nếu bạn không biết liệu một biến có tồn tại hay không (điều đó có nghĩa là, nếu nó được khai báo ), bạn nên kiểm tra với typeoftoán tử. Ví dụ

if( typeof foo !== 'undefined' ) {
    // foo could get resolved and it's defined
}

Nếu bạn có thể chắc chắn rằng một biến được khai báo ít nhất, bạn nên trực tiếp kiểm tra xem nó có truthygiá trị như được hiển thị ở trên không.

Đọc thêm: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

Phương thức dài dòng để kiểm tra xem giá trị không được xác định hay null là:

return value === undefined || value === null;

Bạn cũng có thể sử dụng ==toán tử nhưng điều này hy vọng một người sẽ biết tất cả các quy tắc :

return value == null; // also returns true if value is undefined

function isEmpty(value){
  return (value == null || value.length === 0);
}

Điều này sẽ trả về đúng cho

undefined  // Because undefined == null

null

[]

""

và các hàm đối số bằng 0 vì một hàm lengthlà số lượng tham số khai báo.

Để không cho phép danh mục sau, bạn có thể chỉ muốn kiểm tra các chuỗi trống

function isEmpty(value){
  return (value == null || value === '');
}

Đây là kiểm tra an toàn nhất và tôi chưa thấy nó được đăng ở đây chính xác như thế:

if (typeof value !== 'undefined' && value) {
    //deal with value'
};

Nó sẽ bao gồm các trường hợp giá trị không bao giờ được xác định và bất kỳ trường hợp nào trong số này:

• vô giá trị
• không xác định (giá trị không xác định không giống với tham số không bao giờ được xác định)
• 0
• "" (Chuỗi trống)
• sai
• NaN

_{Đã chỉnh sửa: Thay đổi thành bình đẳng nghiêm ngặt (! ==) vì bây giờ nó là chuẩn mực;)}

Bạn có thể thấy chức năng sau đây hữu ích:

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

Hoặc trong ES7 (nhận xét nếu cải tiến thêm)

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);

  return type.toLowerCase();
}

Các kết quả:

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

"Lưu ý rằng toán tử liên kết (: :) không phải là một phần của ES2016 (ES7) cũng như bất kỳ phiên bản nào sau này của tiêu chuẩn ECMAScript. Đây hiện là đề xuất giai đoạn 0 (ống hút) để được giới thiệu với ngôn ngữ." - Simon Kjellberg. tác giả muốn thêm hỗ trợ của mình cho đề nghị đẹp này để nhận được sự thăng thiên của hoàng gia.

Câu trả lời đầu tiên với đánh giá tốt nhất là sai. Nếu giá trị không được xác định, nó sẽ ném ngoại lệ trong các trình duyệt hiện đại. Bạn phải sử dụng:

if (typeof(value) !== "undefined" && value)

hoặc là

if (typeof value  !== "undefined" && value)

Kiểm tra điều kiện này

if (!!foo) {
    //foo is defined
}

là tất cả những gì bạn cần.

! kiểm tra các chuỗi rỗng (""), null, không xác định, sai và số 0 và NaN. Nói, nếu một chuỗi trống var name = ""thì console.log(!name)trả về true.

function isEmpty(val){
  return !val;
}

chức năng này sẽ trở thành sự thật nếu val là trống rỗng, null, undefined, false, số 0 hoặc NaN .

HOẶC LÀ

Theo tên miền vấn đề của bạn, bạn chỉ có thể sử dụng như !valhoặc !!val.

Một giải pháp tôi rất thích:

Hãy xác định rằng một biến trống là null, hoặc undefined, hoặc nếu nó có độ dài, nó bằng 0 hoặc nếu nó là một đối tượng, thì nó không có khóa:

function isEmpty (value) {
  return (
    // null or undefined
    (value == null) ||

    // has length and it's zero
    (value.hasOwnProperty('length') && value.length === 0) ||

    // is an Object and has no keys
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

Trả về:

• đúng: undefined , null, "", [],{}
• sai: true , false, 1, 0, -1, "foo", [1, 2, 3],{ foo: 1 }

Bạn có một chút làm quá nó. Để kiểm tra xem một biến không được đưa ra một giá trị, bạn chỉ cần kiểm tra lại không xác định và null.

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}

Đây là giả định 0, ""và các đối tượng (ngay cả đối tượng và mảng trống) là "giá trị" hợp lệ.

Nếu bạn thích javascript đơn giản hãy thử điều này:

  /**
   * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
   * length of `0` and objects with no own enumerable properties are considered
   * "empty".
   *
   * @static
   * @memberOf _
   * @category Objects
   * @param {Array|Object|string} value The value to inspect.
   * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
   * @example
   *
   * _.isEmpty([1, 2, 3]);
   * // => false
   *
   * _.isEmpty([]);
   * // => true
   *
   * _.isEmpty({});
   * // => true
   *
   * _.isEmpty('');
   * // => true
   */

function isEmpty(value) {
    if (!value) {
      return true;
    }
    if (isArray(value) || isString(value)) {
      return !value.length;
    }
    for (var key in value) {
      if (hasOwnProperty.call(value, key)) {
        return false;
      }
    }
    return true;
  }

Mặt khác, nếu bạn đã sử dụng dấu gạch dưới hoặc dấu gạch ngang, hãy thử:

_.isEmpty(value)

Của tôi đây - trả về true nếu giá trị là null, không xác định, v.v hoặc trống (tức là chỉ chứa khoảng trắng):

function stringIsEmpty(value) {

    return value ? value.trim().length == 0 : true;

}

return val || 'Handle empty variable'

là một cách thực sự tốt và sạch để xử lý nó ở nhiều nơi, cũng có thể được sử dụng để gán biến

const res = val || 'default value'

Nếu biến không được khai báo, bạn sẽ không thể kiểm tra không xác định bằng cách sử dụng hàm vì bạn sẽ gặp lỗi.

if (foo) {}
function (bar) {}(foo)

Cả hai sẽ tạo ra một lỗi nếu foo chưa được khai báo.

Nếu bạn muốn kiểm tra nếu một biến đã được khai báo, bạn có thể sử dụng

typeof foo != "undefined"

nếu bạn muốn kiểm tra xem foo đã được khai báo chưa và nó có giá trị bạn có thể sử dụng

if (typeof foo != "undefined" && foo) {
    //code here
}

Để kiểm tra giá trị mặc định

function typeOfVar (obj) {
      return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}
function isVariableHaveDefaltVal(variable) {
    if ( typeof(variable) === 'string' ) {  // number, boolean, string, object 
        console.log(' Any data Between single/double Quotes is treated as String ');        
        return (variable.trim().length === 0) ? true : false;
    }else if ( typeof(variable) === 'boolean' ) {
      console.log('boolean value with default value \'false\'');
        return (variable === false) ? true : false;
    }else if ( typeof(variable) === 'undefined' ) {
        console.log('EX: var a; variable is created, but has the default value of undefined.'); 
        return true;
    }else if ( typeof(variable) === 'number' ) { 
        console.log('number : '+variable);
        return (variable === 0 ) ? true : false;
    }else if ( typeof(variable) === 'object' ) {
   //   -----Object-----
        if (typeOfVar(variable) === 'array' && variable.length === 0) {
            console.log('\t Object Array with length = ' + [].length); // Object.keys(variable)
            return true;
        }else if (typeOfVar(variable) === 'string' && variable.length === 0 ) {
            console.log('\t Object String with length = ' + variable.length);
            return true;
        }else if (typeOfVar(variable) === 'boolean' ) {
            console.log('\t Object Boolean = ' + variable);
            return (variable === false) ? true : false;
        }else if (typeOfVar(variable) === 'number' ) {
            console.log('\t Object Number = ' + variable);
            return (variable === 0 ) ? true : false;
        }else if (typeOfVar(variable) === 'regexp' && variable.source.trim().length === 0 ) {
       console.log('\t Object Regular Expression : ');
        return true;
        }else if (variable === null) {
       console.log('\t Object null value');
        return true;
        }
    }
    return false;
}
var str = "A Basket For Every Occasion";
str = str.replace(/\s/g, "-");
//The "g" flag in the regex will cause all spaces to get replaced.

kiểm tra kết quả:

isVariableHaveDefaltVal(' '); // string          
isVariableHaveDefaltVal(false); // boolean       
var a;           
isVariableHaveDefaltVal(a);               
isVariableHaveDefaltVal(0); // number             
isVariableHaveDefaltVal(parseInt('')); // NAN isNAN(' '); - true         
isVariableHaveDefaltVal(null);              
isVariableHaveDefaltVal([]);               
isVariableHaveDefaltVal(/ /);              
isVariableHaveDefaltVal(new Object(''));               
isVariableHaveDefaltVal(new Object(false));            
isVariableHaveDefaltVal(new Object(0)); 
typeOfVar( function() {} );

Tôi đã sử dụng hàm @Vix () để kiểm tra đối tượng thuộc loại nào.

sử dụng instansof «

var prototypes_or_Literals = function (obj) {
    switch (typeof(obj)) {
        // object prototypes
        case 'object':
            if (obj instanceof Array)
                return '[object Array]';
            else if (obj instanceof Date)
                return '[object Date]';
            else if (obj instanceof RegExp)
                return '[object regexp]';
            else if (obj instanceof String)
                return '[object String]';
            else if (obj instanceof Number)
                return '[object Number]';

            else
                return 'object';
        // object literals
        default:
            return typeof(obj);
    }   
};
output test «
prototypes_or_Literals( '' ) // "string"
prototypes_or_Literals( new String('') ) // "[object String]"
Object.prototype.toString.call("foo bar") //"[object String]"        

function isEmpty(obj) {
    if (typeof obj == 'number') return false;
    else if (typeof obj == 'string') return obj.length == 0;
    else if (Array.isArray(obj)) return obj.length == 0;
    else if (typeof obj == 'object') return obj == null || Object.keys(obj).length == 0;
    else if (typeof obj == 'boolean') return false;
    else return !obj;
}

Trong ES6 có trim để xử lý các chuỗi khoảng trắng:

const isEmpty = value => {
    if (typeof value === 'number') return false
    else if (typeof value === 'string') return value.trim().length === 0
    else if (Array.isArray(value)) return value.length === 0
    else if (typeof value === 'object') return value == null || Object.keys(value).length === 0
    else if (typeof value === 'boolean') return false
    else return !value
}

Nó có thể hữu ích.

Tất cả các giá trị trong mảng đại diện cho những gì bạn muốn trở thành (null, không xác định hoặc những thứ khác) và bạn tìm kiếm những gì bạn muốn trong đó.

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1

Nếu bạn đang sử dụng TypeScriptvà không muốn tính đến "các giá trị đó false" thì đây là giải pháp cho bạn:

Đầu tiên: import { isNullOrUndefined } from 'util';

Sau đó: isNullOrUndefined(this.yourVariableName)

Xin lưu ý: Như đã đề cập dưới đây, điều này hiện không được chấp nhận, value === undefined || value === nullthay vào đó hãy sử dụng . ref .

Vắc xin

Tôi không khuyên bạn nên cố gắng xác định hoặc sử dụng hàm tính toán xem có giá trị nào trên toàn thế giới không. "Thực sự" có nghĩa là gì? Nếu tôi có let human = { name: 'bob', stomach: 'empty' }, nên isEmpty(human)trở về true? Nếu tôi có let reg = new RegExp('');, nên isEmpty(reg)trở về true? Thế còn isEmpty([ null, null, null, null ])- danh sách này chỉ chứa sự trống rỗng, vậy bản thân danh sách có trống không? Tôi muốn đưa ra ở đây một số lưu ý về "khoảng trống" (một từ có chủ ý tối nghĩa, để tránh các liên kết có sẵn) trong javascript - và tôi muốn tranh luận rằng "khoảng trống" trong các giá trị javascript không bao giờ nên được xử lý một cách khái quát.

Sự thật / giả dối

Để quyết định làm thế nào để xác định "độ trống" của các giá trị, chúng ta cần phải bổ sung sẵn nội dung của javascript, ý thức vốn có về việc các giá trị là "trung thực" hay "giả mạo". Đương nhiên, nullvà undefinedcả hai đều là "giả". Ít tự nhiên hơn, số 0(và không có số nào khác ngoại trừ NaN) cũng là "giả". Ít nhất là tự nhiên: ''là giả, nhưng []và {}(và new Set(), và new Map()) là sự thật - mặc dù tất cả đều có vẻ trống rỗng như nhau!

Null vs Không xác định

Ngoài ra còn có một số cuộc thảo luận liên quan đến nullvs undefined- chúng ta có thực sự cần cả hai để thể hiện sự trống rỗng trong các chương trình của mình không? Cá nhân tôi tránh bao giờ có các chữ cái u, n, d, e, f, i, n, e, d xuất hiện trong mã của tôi theo thứ tự đó. Tôi luôn luôn sử dụng nullđể biểu thị "sự trống rỗng". Mặc dù vậy, một lần nữa, chúng ta cần thể hiện ý thức vốn có của javascript về cách thức nullvà sự undefinedkhác biệt:

• Cố gắng truy cập vào một tài sản không tồn tại cho undefined
• Bỏ qua một tham số khi gọi một hàm dẫn đến việc nhận tham số đó undefined:

let f = a => a;
console.log(f('hi'));
console.log(f());

• Các tham số có giá trị mặc định chỉ nhận mặc định khi được cung cấp undefined, không null:

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

Vắc xin không chung chung

Tôi tin rằng sự trống rỗng không bao giờ nên được xử lý theo cách chung chung. Thay vào đó, chúng ta nên luôn luôn có sự nghiêm ngặt để có thêm thông tin về dữ liệu của mình trước khi xác định xem nó có bị bỏ trống không - tôi chủ yếu làm điều này bằng cách kiểm tra loại dữ liệu nào tôi đang xử lý:

let isType = (value, Cls) => {
  try {
    return Object.getPrototypeOf(value).constructor === Cls;
  } catch(err) {
    return false;
  }
};

Lưu ý rằng hàm này bỏ qua tính đa hình - nó dự kiến valuelà một thể hiện trực tiếp Clsvà không phải là một thể hiện của một lớp con của Cls. Tôi tránh instanceofvì hai lý do chính:

• ([] instanceof Object) === true ("Một mảng là một đối tượng")
• ('' instanceof String) === false ("Chuỗi không phải là Chuỗi")

Lưu ý rằng Object.getPrototypeOfđược sử dụng để tránh trường hợp như thế let v = { constructor: String };Các isTypechức năng vẫn trả về đúng cho isType(v, String)(false), và isType(v, Object)(true).

Nhìn chung, tôi khuyên bạn nên sử dụng isTypechức năng này cùng với các mẹo sau:

• Giảm thiểu số lượng giá trị xử lý mã của loại không xác định. Ví dụ, cho let v = JSON.parse(someRawValue);, vbiến của chúng tôi bây giờ là loại không xác định. Càng sớm càng tốt, chúng ta nên hạn chế khả năng của mình. Cách tốt nhất để làm điều này có thể là bằng cách yêu cầu một loại cụ thể: ví dụ: if (!isType(v, Array)) throw new Error('Expected Array');đây là cách thực sự nhanh chóng và biểu cảm để loại bỏ bản chất chung của vvà đảm bảo nó luôn luôn là một Array. Đôi khi, mặc dù, chúng ta cần phải cho phép vcó nhiều loại. Trong những trường hợp đó, chúng ta nên tạo các khối mã vkhông còn chung chung, càng sớm càng tốt:

if (isType(v, String)) {
  /* v isn't generic in this block - It's a String! */
} else if (isType(v, Number)) {
  /* v isn't generic in this block - It's a Number! */
} else if (isType(v, Array)) {
  /* v isn't generic in this block - it's an Array! */
} else {
  throw new Error('Expected String, Number, or Array');
}

• Luôn sử dụng "danh sách trắng" để xác nhận. Nếu bạn yêu cầu một giá trị là, ví dụ: Chuỗi, Số hoặc Mảng, hãy kiểm tra 3 khả năng "trắng" đó và ném Lỗi nếu không có gì trong số 3 được thỏa mãn. Chúng ta nên có thể thấy rằng việc kiểm tra đối với khả năng "đen" không phải là rất hữu ích: Nói chúng tôi viết if (v === null) throw new Error('Null value rejected');- điều này là rất tốt cho việc đảm bảo rằng nullgiá trị này không làm cho nó qua, nhưng nếu một giá trị không làm cho nó qua, chúng tôi vẫn biết khó bất cứ thứ gì về nó. Một giá trị vvượt qua kiểm tra null này vẫn còn RẤT chung chung - đó là bất cứ điều gì nhưngnull ! Danh sách đen hầu như không xua tan sự chung chung.

• Trừ khi một giá trị là null, không bao giờ coi "một giá trị trống". Thay vào đó, hãy xem xét "một chữ X trống". Về cơ bản, không bao giờ xem xét làm bất cứ điều gì như if (isEmpty(val)) { /* ... */ }- cho dù isEmptychức năng đó được thực hiện như thế nào (tôi không muốn biết ...), điều đó không có ý nghĩa! Và đó là cách quá chung chung! Độ trống chỉ nên được tính toán với kiến ​​thức về valloại. Kiểm tra phòng ngừa nên như thế này:

  • "Một chuỗi, không có ký tự": if (isType(val, String) && val.length === 0) ...
  • "Một đối tượng, với 0 đạo cụ": if (isType(val, Object) && Object.entries(val).length === 0) ...
  • "Một số, bằng hoặc nhỏ hơn 0": if (isType(val, Number) && val <= 0) ...

  • "Một mảng, không có mục nào": if (isType(val, Array) && val.length === 0) ...

  • Ngoại lệ duy nhất là khi nullđược sử dụng để biểu thị chức năng nhất định. Trong trường hợp này, thật ý nghĩa khi nói: "Một giá trị trống":if (val === null) ...

Hãy thử với logic khác nhau . Bạn có thể sử dụng mã dưới đây để kiểm tra tất cả bốn (4) điều kiện để xác thực như không null, không trống, không xác định và không zero chỉ sử dụng mã này (! (! (Biến))) trong javascript và jquery.

function myFunction() {
    var data;  //The Values can be like as null, blank, undefined, zero you can test

    if(!(!(data)))
    {
        alert("data "+data);
    } 
    else 
    {
        alert("data is "+data);
    }
}

Hãy xem toán tử kết hợp ECMAScript Nullish mới

Bạn có thể nghĩ về tính năng này - ??nhà điều hành - như một cách để đưa rơi trở lại giá trị mặc định khi giao dịch với nullhoặc undefined.

let x = foo ?? bar();

Một lần nữa, đoạn mã trên tương đương với đoạn sau.

let x = (foo !== null && foo !== undefined) ? foo : bar();

function isEmpty(val){
    return !val;
}

nhưng giải pháp này được thiết kế quá mức, nếu bạn không muốn sửa đổi chức năng sau này cho các nhu cầu mô hình busines, thì sẽ sạch hơn để sử dụng nó trực tiếp trong mã:

if(!val)...

var myNewValue = myObject && myObject.child && myObject.child.myValue;

Điều này sẽ không bao giờ ném một lỗi. Nếu myObject , con hoặc myValue là null thì myNewValue sẽ là null. Không có lỗi sẽ được ném

Đối với tất cả mọi người đến đây vì có câu hỏi tương tự, những điều sau đây rất tuyệt và tôi có nó trong thư viện của tôi những năm qua:

(function(g3, $, window, document, undefined){
   g3.utils = g3.utils || {};
/********************************Function type()********************************
* Returns a lowercase string representation of an object's constructor.
* @module {g3.utils}
* @function {g3.utils.type}
* @public
* @param {Type} 'obj' is any type native, host or custom.
* @return {String} Returns a lowercase string representing the object's 
* constructor which is different from word 'object' if they are not custom.
* @reference http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
* http://stackoverflow.com/questions/3215046/differentiating-between-arrays-and-hashes-in-javascript
* http://javascript.info/tutorial/type-detection
*******************************************************************************/
g3.utils.type = function (obj){
   if(obj === null)
      return 'null';
   else if(typeof obj === 'undefined')
      return 'undefined';
   return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1].toLowerCase();
};
}(window.g3 = window.g3 || {}, jQuery, window, document));

Nếu bạn muốn tránh nhận đúng nếu giá trị là bất kỳ giá trị nào sau đây, theo câu trả lời của jAndy :

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

Một giải pháp khả thi có thể tránh nhận được các giá trị trung thực là:

function isUsable(valueToCheck) {
    if (valueToCheck === 0     || // Avoid returning false if the value is 0.
        valueToCheck === ''    || // Avoid returning false if the value is an empty string.
        valueToCheck === false || // Avoid returning false if the value is false.
        valueToCheck)             // Returns true if it isn't null, undefined, or NaN.
    {
        return true;
    } else {
        return false;
    }
}

Nó sẽ được sử dụng như sau:

if (isUsable(x)) {
    // It is usable!
}
// Make sure to avoid placing the logical NOT operator before the parameter (isUsable(!x)) and instead, use it before the function, to check the returned value.
if (!isUsable(x)) {
    // It is NOT usable!
}

Ngoài các kịch bản đó, bạn có thể muốn trả về false nếu đối tượng hoặc mảng trống:

• Đối tượng: {} (Sử dụng ECMA 7+ )
• Mảng: [] (Sử dụng ECMA 5+ )

Bạn sẽ đi về nó theo cách này:

function isEmptyObject(valueToCheck) {
    if(typeof valueToCheck === 'object' && !Object.keys(valueToCheck).length){
        // Object is empty!
        return true;
    } else {
        // Object is not empty!
        return false;
    }
}

function isEmptyArray(valueToCheck) {
    if(Array.isArray(valueToCheck) && !valueToCheck.length) {
        // Array is empty!
        return true;
    } else {
        // Array is not empty!
        return false;
    }
}

Nếu bạn muốn kiểm tra tất cả các chuỗi khoảng trắng (""), bạn có thể làm như sau:

function isAllWhitespace(){
    if (valueToCheck.match(/^ *$/) !== null) {
        // Is all whitespaces!
        return true;
    } else {
        // Is not all whitespaces!
        return false;
    }
}

Lưu ý: hasOwnPropertytrả về true cho các chuỗi rỗng, 0, false, NaN, null và không xác định, nếu biến được khai báo là bất kỳ trong số chúng, vì vậy nó có thể không phải là tốt nhất để sử dụng. Hàm này có thể được sửa đổi để sử dụng nó để hiển thị rằng nó đã được khai báo, nhưng không thể sử dụng được.

Mã trên GitHub

const isEmpty = value => (
  (!value && value !== 0 && value !== false)
  || (Array.isArray(value) && value.length === 0)
  || (isObject(value) && Object.keys(value).length === 0)
  || (typeof value.size === 'number' && value.size === 0)

  // `WeekMap.length` is supposed to exist!?
  || (typeof value.length === 'number'
      && typeof value !== 'function' && value.length === 0)
);

// Source: https://levelup.gitconnected.com/javascript-check-if-a-variable-is-an-object-and-nothing-else-not-an-array-a-set-etc-a3987ea08fd7
const isObject = value =>
  Object.prototype.toString.call(value) === '[object Object]';

Bài kiểm tra của người nghèo

const test = () => {
  const run = (label, values, expected) => {
    const length = values.length;
    console.group(`${label} (${length} tests)`);
    values.map((v, i) => {
      console.assert(isEmpty(v) === expected, `${i}: ${v}`);
    });
    console.groupEnd();
  };

  const empty = [
    null, undefined, NaN, '', {}, [],
    new Set(), new Set([]), new Map(), new Map([]),
  ];
  const notEmpty = [
    ' ', 'a', 0, 1, -1, false, true, {a: 1}, [0],
    new Set([0]), new Map([['a', 1]]),
    new WeakMap().set({}, 1),
    new Date(), /a/, new RegExp(), () => {},
  ];
  const shouldBeEmpty = [
    {undefined: undefined}, new Map([[]]),
  ];

  run('EMPTY', empty, true);
  run('NOT EMPTY', notEmpty, false);
  run('SHOULD BE EMPTY', shouldBeEmpty, true);
};

Kết quả kiểm tra:

EMPTY (10 tests)
NOT EMPTY (16 tests)
SHOULD BE EMPTY (2 tests)
  Assertion failed: 0: [object Object]
  Assertion failed: 1: [object Map]

Điều này sẽ kiểm tra xem biến số của lồng không xác định là không xác định

function Undef(str) 
{
  var ary = str.split('.');
  var w = window;
  for (i in ary) {
    try      { if (typeof(w = w[ary[i]]) === "undefined") return true; }
    catch(e) { return true; }
  }
  return false;
}

if (!Undef("google.translate.TranslateElement")) {

Các kiểm tra ở trên nếu chức năng dịch Google DịchEEuity tồn tại. Điều này tương đương với:

if (!(typeof google === "undefined" 
 || typeof google.translate === "undefined" 
 || typeof google.translate.TranslateElement === "undefined")) {

Toán tử chuỗi tùy chọn cung cấp một cách để đơn giản hóa việc truy cập các giá trị thông qua các đối tượng được kết nối khi có thể tham chiếu hoặc hàm có thể không được xác định hoặc null.

let customer = {
  name: "Carl",
  details: {
    age: 82,
    location: "Paradise Falls" // detailed address is unknown
  }
};
let customerCity = customer.details?.address?.city;

Toán tử kết hợp nullish có thể được sử dụng sau khi xâu chuỗi tùy chọn để tạo giá trị mặc định khi không tìm thấy:

let customer = {
  name: "Carl",
  details: { age: 82 }
};
const customerCity = customer?.city ?? "Unknown city";
console.log(customerCity); // Unknown city

function notEmpty(value){
  return (typeof value !== 'undefined' && value.trim().length);
}

nó cũng sẽ kiểm tra các khoảng trắng ('') cùng với:

• null, không xác định, NaN, trống, chuỗi (""), 0, sai

Tôi nghĩ rằng sử dụng? Toán tử sạch hơn một chút.

var ? function_if_exists() : function_if_doesnt_exist();