是否有标准函数来检查 JavaScript 中的 null、未定义或空白变量？

Question

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

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

Answer 1

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

if( value ) {
}

如果value 不是，则评估为true：

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

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

此外，如果您不知道变量是否存在（也就是说，如果它被声明），您应该使用typeof 运算符进行检查。比如

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

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

Answer 2

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

这将返回 true

undefined  // Because undefined == null

null

[]

""

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

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

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

Answer 3

检查值是否未定义或为空的详细方法是：

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

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

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

Answer 4

你有点过头了。要检查一个变量是否没有赋值，你只需要检查 undefined 和 null。

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

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

Answer 5

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

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

如果 foo 没有被声明，两者都会产生错误。

如果你想测试一个变量是否已经被声明，你可以使用

typeof foo != "undefined"

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

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

Answer 6

这是最安全的检查，我还没有看到它完全像这样张贴在这里：

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

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

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

_{已编辑：更改为严格相等 (!==)，因为它现在已成为常态；)}

Answer 7

这是我的 - 如果值为 null、未定义等或空白（即仅包含空格），则返回 true：

function stringIsEmpty(value) {

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

}

Answer 8

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

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

或

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

Answer 9

! 检查空字符串 ("")、null、undefined、false 以及数字 0 和 NaN。 假设一个字符串为空 var name = "" 然后console.log(!name) 返回true。

function isEmpty(val){
  return !val;
}

如果 val 为 empty、null、undefined、false、数字 0 或 NaN，此函数将返回 true。

或

根据您的问题域，您可以使用 !val 或 !!val。

Answer 10

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

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 11

这个条件检查

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

就是你所需要的。

Answer 12

如果你喜欢纯 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 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 function() 来检查对象的类型。

使用实例 «

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

我认为使用 ?运算符稍微干净一些。

var ? function_if_exists() : function_if_doesnt_exist();

Answer 15

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

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

以上检查是否存在谷歌翻译函数 TranslateElement。这相当于：

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

Answer 16

对于我的情况，我尝试使用 if null,'', !variable，但它不起作用。

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

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

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

以下代码有效。

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

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

Answer 17

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

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 18

function isEmpty(val){
    return !val;
}

但是这个解决方案是过度设计的，如果您不想稍后修改该功能以满足业务模型的需要，那么直接在代码中使用它会更干净：

if(!val)...

Answer 19

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

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

Answer 20

对于遇到类似问题的每个人来说，以下内容非常有用，我在过去几年的图书馆中有它：

(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 21

可能有用。

数组中的所有值都代表您想要成为的内容（null、未定义或其他内容），您可以在其中搜索您想要的内容。

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

Answer 22

此函数检查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) -> 真
val=[];
isEmpty(val) -> 真
isEmpty(未定义) -> true
isEmpty(null) -> 真
isEmpty("") -> 真
isEmpty(false) -> 假
isEmpty(0) -> 假

Answer 23

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

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

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

Answer 24

尝试不同的逻辑。您可以使用波纹管代码检查所有四 (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 25

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 26

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

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

然后：isNullOrUndefined(this.yourVariableName)

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

Answer 27

try{

     let vari = obj.propTest; // obj may be don't have propTest property

        ...
} catch(NullException){
    // do something here
}

我认为使用 try catch 可以避免 null 检查的任何错误，在 Angular 或 JavaScript 中也是如此 只是捕获空异常并在其中处理。

Answer 28

return val || 'Handle empty variable'

在很多地方都是一种非常干净整洁的处理方式，也可以用于分配变量

const res = val || 'default value'

Answer 29

我非常喜欢的解决方案：

让我们定义一个空白变量是null，或者undefined，或者如果它有长度，它是零，或者如果它是一个对象，它没有键：

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

返回：

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

Answer 30

空虚

我不建议尝试定义或使用计算整个世界中的任何值是否为空的函数。 “空”的真正含义是什么？如果我有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()）是真实的 - 尽管它们看起来都同样空洞！

---

空与未定义

还有一些关于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));

对我来说，null 是一个明确的空洞符号； “本来可以填写的东西故意留空”。

真的undefined 是一个必要的复杂性，它允许一些 js 功能存在，但在我看来 它应该始终留在幕后；没有直接互动。例如，我们可以将undefined 视为 javascript 实现默认函数参数的机制。如果您不向函数提供参数，它将收到 undefined 的值。如果该参数最初设置为undefined，则默认值将应用于函数参数。在这种情况下，undefined 是默认函数参数的关键，但它保留在后台：我们可以实现默认参数功能，而无需参考 undefined：

这是默认参数的错误实现，因为它直接与 undefined 交互：

let fnWithDefaults = arg => {
  if (arg === undefined) arg = 'default';
  ...
};

这是一个很好的实现：

let fnWithDefaults = (arg='default') => { ... };

这是接受默认参数的不好方法：

fnWithDefaults(undefined);

只需这样做：

fnWithDefaults();

---

非泛型空虚

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

let isType = (value, Cls) => {
  // Intentional use of loose comparison operator detects `null`
  // and `undefined`, and nothing else!
  return value != null && Object.getPrototypeOf(value).constructor === Cls;
};

请注意，此函数忽略继承 - 它期望 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 值不会通过它非常有用，但是如果一个值 确实 通过了，我们仍然对此一无所知。通过此 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) ...