闲适

Question

是否存在通用JavaScript函数，用于检查变量是否具有值并确保它不是undefined或null？我有这个代码，但我不确定它是否涵盖了所有情况：

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

Answer 1

您可以检查变量是否具有truthy值。这意味着

if( value ) {
}

如果true 不，

将评估为value：

空
未定义
的NaN
空字符串（“”）
0
假

以上列表代表ECMA- / Javascript中所有可能的falsy值。请在ToBoolean部分的specification中找到它。

此外，如果您不知道是否存在变量（即，如果声明），您应该与typeof运算符一起检查。例如

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

如果您确定至少声明了变量，则应直接检查它是否具有如上所示的truthy值。

进一步阅读：http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

Answer 2

检查值是未定义还是null的详细方法是：

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

您也可以使用==运算符，但这需要一个know all the rules：

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

Answer 3

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

将返回true

undefined  // Because undefined == null

null

[]

""

和零参数函数，因为函数length是它所声明的参数的数量。

要禁止后一种类别，您可能只想检查空字符串

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

Answer 4

我知道这是一个老问题，但这是最安全的检查，我没有看到它在这里张贴的那样：

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

它将涵盖从未定义值的情况，以及以下任何一种情况：

空
undefined（undefined的值与从未定义的参数不同）
0
“”（空字符串）
假
的NaN

P.S。 typeof value中没有必要严格平等！='undefined'

Answer 5

您可能会发现以下功能有用：

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

或在ES7中（如果进一步改进则发表评论）

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

  return type.toLowerCase();
}

结果：

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

“请注意，绑定运算符（：:)不是ES2016（ES7）的一部分，也不是ECMAScript标准的任何后续版本。它目前是引入该语言的第0阶段（草编）提议。” - 西蒙凯尔伯格作者希望加入他对这一美丽提案的支持，以获得皇室提升。

Answer 6

评分最高的第一个答案是错误的。如果value未定义，它将在现代浏览器中引发异常。你必须使用：

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

或

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

Answer 7

！检查空字符串（“”），null，undefined，false以及数字0和NaN。说，如果字符串为空{{1}然后var name = ""返回console.log(!name)。

true

如果 val 为空，null，未定义，false，数字0或NaN ，此函数将返回true。

或

根据您的问题域，您可以使用function isEmpty(val){ return !val; }或!val。

Answer 8

你有点过头了。要检查变量是否没有给出值，您只需要检查undefined和null。

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

假设0，""，对象（甚至是空对象和数组）都是有效的“值”。

Answer 9

这是我的 - 如果value为null，undefined等等或空白（即只包含空格），则返回true：

function stringIsEmpty(value) {

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

}

Answer 10

如果您更喜欢简单的javascript，请尝试：

  /**
   * 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;
  }

否则，如果您已经使用了下划线或lodash，请尝试：

_.isEmpty(value)

Answer 11

看看新的ECMAScript Nullish coalescing operator

您可以考虑使用??运算符这一功能，作为在处理null或undefined时“回退”到默认值的一种方法。

let x = foo ?? bar();

同样，上面的代码等同于下面的代码。

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

Answer 12

我将留下我非常喜欢的注册解决方案：

首先让我们定义一个空白变量为null或undefined，或者如果它的长度为0，或者为对象，则没有键：

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)
  )
}

返回：

true：：undefined，null，""，[]，{}
否：：true，false，1，0，-1，"foo"，{{ 1}}，[1, 2, 3]

Answer 13

检查默认值

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.

检查结果：

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() {} );

我使用@Vix函数（）来检查哪种类型的对象。

使用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]"

Answer 14

return val || 'Handle empty variable'

是在很多地方处理它的一种非常好和干净的方法，也可以用于分配变量

const res = val || 'default value'

Answer 15

可能最短的答案是

val==null || val==''

如果将约束面更改为val===''，则空数组将为false。证明

function isEmpty(val){
    return val==null || val==''
}

// ------------
// TEST
// ------------

var log = (name,val) => console.log(`${name} -> ${isEmpty(val)}`);

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" - so we should get here TRUE

有关==（来源here）的更多详细信息

奖金：===比==更加清晰的原因

写得清晰，容易易懂的代码，使用可接受值的显式列表

val===undefined || val===null || val===''|| (Array.isArray(val) && val.length===0)

function isEmpty(val){
    return val===undefined || val===null || val==='' || (Array.isArray(val) && val.length===0)
}

// ------------
// TEST
// ------------

var log = (name,val) => console.log(`${name} -> ${isEmpty(val)}`);

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" - so we should get here TRUE

Answer 16

如果您使用的是 TypeScript ，并且不想考虑“这些值是false” ，那么这就是解决方案您：

第一位：import { isNullOrUndefined } from 'util';

然后：isNullOrUndefined(this.yourVariableName)

请注意：如上所述，below已被弃用，请改用value === undefined || value === null。 ref。

Answer 17

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;
}

在ES6中使用trim来处理空白字符串：

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
}

Answer 18

它可能很有用。

[null, undefined, ''].indexOf(document.DocumentNumberLabel) > -1

Answer 19

如果未声明变量，则无法使用函数测试未定义，因为您将收到错误。

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

如果未声明foo，两者都会产生错误。

如果要测试是否已声明变量，可以使用

typeof foo != "undefined"

如果你想测试foo是否已被声明并且它有一个值你可以使用

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

Answer 20

您可以使用波纹管代码检查所有四（4）个条件以进行验证，如非空，非空白，未定义，而不是零只在javascript和jquery中使用此代码（！（！（variable）））。

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);
    }
}

Answer 21

对于所有来这里有类似问题的人来说，以下工作很有效，我在过去的几年里在我的图书馆里有这个：

(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));

Answer 22

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

这绝不会引发错误。如果 myObject ， child 或 myValue 为null，则 myNewValue 将为null。不会抛出任何错误

Answer 23

Code on 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]';

可怜的人的测试?

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);
};

测试结果：

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

Answer 24

function isEmpty(val){
    return !val;
}

但是这个解决方案是过度设计的，如果你以后想要修改函数以满足商业模型需求，那么在代码中直接使用它就更清晰了：

if(!val)...

Answer 25

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

它还将检查空格（''）以及以下内容：

null，未定义，NaN，空，string（“”），0，false

Answer 26

闲适

我不建议尝试定义或使用一个函数来计算整个世界是否为空。 “空”到底意味着什么？如果我有let human = { name: 'bob', stomach: 'empty' }，isEmpty(human)应该返回true吗？如果我有let reg = new RegExp('');，isEmpty(reg)应该返回true吗？ isEmpty([ null, null, null, null ])呢？此列表仅包含空值，因此列表本身为空？我想在这里提出一些有关javascript中的“空缺”（故意模糊的词，以避免预先存在的关联）的注意事项-并且我想辩称javascript值中的“空缺”永远都不应加以处理。

真实/虚假

要确定如何确定值的“空缺”，我们需要适应javascript对值是“真实”还是“虚假”的内在固有感觉。自然，null和undefined都是“虚假的”。不太自然的是，数字0（除NaN外没有其他数字）也是“虚假的”。至少自然而然：''是虚假的，但是[]和{}（以及new Set()和new Map()）是真实的-尽管它们看起来都一样虚空！ >

空vs未定义

关于null与undefined的讨论也有所涉及-为了在程序中表达虚无，我们真的需要两者吗？我个人避免在我的代码中按顺序出现字母u，n，d，e，f，i，n，e，d。我总是使用null来表示“空缺”。同样，尽管如此，我们需要适应javascript对null和undefined有何不同的内在含义：

尝试访问不存在的属性会给undefined
在调用函数时省略参数会导致该参数接收undefined：

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

具有默认值的参数仅在给定undefined而不是null时才接受默认值：

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

非一般性休克

我认为，空虚绝不应该以一般方式处理。相反，在确定数据是否为空之前，我们应该始终严格要求获取有关数据的更多信息-我主要是通过检查要处理的数据类型来做到这一点的：

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

请注意，此函数忽略多态性-它期望value是Cls的直接实例，而不是Cls的子类的实例。我避免使用instanceof有两个主要原因：

([] instanceof Object) === true（“数组就是对象”）
('' instanceof String) === false（“字符串不是字符串”）

请注意，Object.getPrototypeOf用于避免出现类似let v = { constructor: String };的情况。isType函数对于isType(v, String)（false）和isType(v, Object)（true ）。

总体而言，我建议将此isType函数与这些提示一起使用：

最小化未知类型的代码处理值。例如，对于let v = JSON.parse(someRawValue);，我们的v变量现在为未知类型。我们应该尽早限制我们的可能性。最好的方法可以是通过要求一种特定的类型： if (!isType(v, Array)) throw new Error('Expected Array');-这是删除v的通用属性并确保它始终是Array的一种非常快速且富有表现力的方法。不过，有时候我们需要允许v为多种类型。在这种情况下，我们应该尽早创建v不再通用的代码块：

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');
}

始终使用“白名单”进行验证。如果您要求使用的值是字符串，数字或数组，请检查这3种“白色”可能性，如果出现，则抛出错误3个都不满意。我们应该能够看到检查“黑色”可能性不是很有用：说我们写if (v === null) throw new Error('Null value rejected');-这对于确保null值不会通过是很有用的，但是如果值确实成功了，我们对此一无所知。通过此空检查的值v仍然非常通用-它是除null 之外的任何内容！黑名单很难消除通用性。
除非值是null，否则永远不要考虑“虚空值”。相反，请考虑“空虚的X”。本质上，永远不要考虑做类似if (isEmpty(val)) { /* ... */ }的事情-不管isEmpty函数是如何实现的（我都不知道。。），没有任何意义！而且太普通了！仅应在了解val类型的情况下才能计算出连通性。连通性检查应如下所示：
- “没有字符的字符串”： if (isType(val, String) && val.length === 0) ...
- “带有0个道具的物体”：if (isType(val, Object) && Object.entries(val).length === 0) ...
- “一个等于或小于零的数字”：if (isType(val, Number) && val <= 0) ...
- “一个没有项目的数组”：if (isType(val, Array) && val.length === 0) ...
- 唯一的例外是使用null表示某些功能时。在这种情况下，有意义的是说：“虚空值”：if (val === null) ...

Answer 27

根据jAndy's answer，如果您希望避免值为以下任何一项，则返回true：

空
未定义
NaN
空字符串（“”）
0
false

一种可能避免获得真实值的解决方案如下：

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;
    }
}

它的用法如下：

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!
}

除了这些情况外，如果 object 或 array 为空，您可能还想返回false：

对象：{}（使用ECMA 7+）
数组：[]（使用ECMA 5+）

您可以这样处理：

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;
    }
}

如果您希望检查所有空格字符串（“”），则可以执行以下操作：

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

注意：hasOwnProperty对于空字符串，0，false，NaN，null和undefined（如果变量被声明为其中的任何一个）返回true，因此可能不是最好的用法。可以修改该函数以使用它来表明它已被声明，但不可用。

Answer 28

当引用或函数可能未定义或为null时，可选的链接运算符提供了一种简化通过连接的对象访问值的方法。

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

在未找到可选值之后，可以使用无效的合并运算符来建立默认值：

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

Answer 29

您可以使用空合并运算符 ?? 来检查 null 和 undefined 值。请参阅MDN Docs

null ?? 'default string'; // returns "default string"

0 ?? 42;  // returns 0

(null || undefined) ?? "foo"; // returns "foo"

Answer 30

尝试使用Boolean()和isNaN()（用于数字类型）检查变量是否具有值。

import { ReactComponent as Logo } from './logo.svg';
const App = () => (
  <div>
    {/* Logo is an actual React component */}
    <Logo fill='red' stroke='green'/>
  </div>
);

Answer 31

这将检查不确定嵌套的变量是否未定义

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")) {

以上检查Google翻译功能TranslateElement是否存在。这相当于：

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

Answer 32

这也涵盖了空数组和空对象

null，未定义，''，0，[]，{}

isEmpty = (value) => (!value  || (typeof v === 'object' &&
   Object.keys(value).length < 1));

Answer 33

ws://localhost:8000

我认为使用try catch可以避免在Angular或JavaScript中出现任何null检查错误只是捕获空异常并在其中进行处理。

Answer 34

以下为我工作。请稍作更改以加快速度

function isEmpty(obj) {
    if (!obj) return true;
    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;
}

Answer 35

对于我的用例，大多数现有答案均失败，如果将函数分配给变量或返回NaN，则大多数返回的结果为空。 Pascal的回答很好。

这是我的实现，请进行测试，如果有发现，请告知我。您可以看到我如何测试此功能here。

function isEmpty(value) {
  return (
    // Null or undefined.
    (value == null) ||
    // Check if a Set() or Map() is empty
    (value.size === 0) ||
    // NaN - The only JavaScript value that is unequal to itself.
    (value !== value) ||
    // Length is zero && it's not a function.
    (value.length === 0 && typeof value !== "function") ||
    // Is an Object && has no keys.
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

返回：

true：：undefined，null，""，[]，{}，NaN，{{ 1}}，new Set()
否：：//，true，false，1，0，-1，{{ 1}}，"foo"，[1, 2, 3]

Answer 36

虽然是老人，但忘了是他们应该包装他们的代码块然后捕获错误然后测试......

function checkup( t ){
  try{
    for(p in t){
      if( p.hasOwnProperty( t ) ){
        return true;
      }
    }
    return false;
  }catch(e){
    console.log("ERROR : "+e);
    return e;
  }
}

所以你真的不必事先检查潜在的问题，你只需抓住它然后按照你想要的方式处理它。

Answer 37

您可以使用参数
成为数组的参数
过滤器

function validateAttrs(arg1, arg2, arg3,arg4){
    var args = Object.values(arguments);
    return (args.filter(x=> x===null || !x)).length<=0
}
console.log(validateAttrs('1',2, 3, 4));
console.log(validateAttrs('1',2, 3, null));
console.log(validateAttrs('1',undefined, 3, 4));
console.log(validateAttrs('1',2, '', 4));
console.log(validateAttrs('1',2, 3, null));

Answer 38

仅对false和undefined返回null：

return value ?? false

Answer 39

我认为使用？操作员稍微清洁。

var ? function_if_exists() : function_if_doesnt_exist();

Answer 40

您可以直接使用相等运算符

<script>
    var firstName;
    var lastName = null;
    /* Since null == undefined is true, the following statements will catch both null and undefined */
        if(firstName == null){
            alert('Variable "firstName" is undefined.');
        }    
        if(lastName == null){
           alert('Variable "lastName" is null.');
        }
</script>

demo @ How to determine if variable is undefined or null using JavaScript

Answer 41

此功能会检查empty object {}，empty array []，null，undefined和blank string ""

function isEmpty(val) {
  //check for empty object {}, array []
  if (val !== null && typeof val === 'object') {
    if (Object.keys(obj).length === 0) {
      return true;
    }
  }
  //check for undefined, null and "" 
  else if (val == null || val === "") {
    return true;
  }
  return false;
}

var val = {};
   isEmpty（val） - ＆gt;真正
  VAL = [];
  isEmpty（val） - ＆gt;真正
  isEmpty（undefined） - ＆gt;真正
  isEmpty（null） - ＆gt;真正
  isEmpty（“”） - ＆gt;真正
  isEmpty（false） - ＆gt;假
  isEmpty（0） - ＆gt;假的

Answer 42

对于我的情况，我尝试使用if null，'，！变量，但它不起作用。

请参阅下面的代码，从html字段中获取文本

var status=$(this).text(); //for example (for my case)

如果状态变量中没有值（没有文本），我试图将值'novalue'设置为状态变量。

以下代码有效。

if(status == false)
{
   status='novalue';
}

当没有找到satus变量的文本时，上面的代码为状态变量分配了“novalue”

Answer 43

您始终可以使用loadash函数，例如_.nil或_.undefined。它们非常好用。

是否有标准函数来检查JavaScript中的null，undefined或blank变量？

43 个答案:

闲适

真实/虚假

空vs未定义

非一般性休克