是否有一个标准函数来检查javascript中的null、undefined, blank 变量？


Is there a standard function to check for null, undefined, or blank variables in JavaScript?

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

1
2
3
function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}
相关讨论

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

1
2
if( value ) {
}

如果value不是：

  • 无效的
  • 未定义
  • 南
  • 空字符串(")
  • 零
  • 假

上面的列表表示ecma-/javascript中所有可能的falsy值。在ToBoolean部分的规范中找到它。

此外，如果您不知道变量是否存在(也就是说，如果声明了变量)，那么应该使用typeof运算符进行检查。例如

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

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

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

相关讨论

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

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

您也可以使用==运算符，但这要求您了解所有规则：

1
return value == null; // also returns true if value is undefined
相关讨论

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

这将返回真为

1
2
3
4
5
6
7
undefined  // Because undefined == null

null

[]

""

零参数函数，因为函数的length是它所使用的声明参数的数目。

要禁用后一个类别，您可能只需要检查空字符串

1
2
3
function isEmpty(value){
  return (value == null || value === '');
}
相关讨论

我知道这是一个老问题，但这是最安全的支票，我还没有看到它像这样贴在这里：

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

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

  • 无效的
  • 未定义(未定义的值与从未定义的参数不同)
  • 零
  • "(空字符串)
  • 假
  • 南

P.S.不需要在类型值上严格相等！="未定义"

相关讨论

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

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

或在ES7中(如果进一步改进，请评论)

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

  return type.toLowerCase();
}

结果：

1
2
3
4
5
6
7
8
9
10
11
12
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阶段(Strawman)的提议，用于介绍该语言。"—Simon Kjellberg。作者希望增加他对这个美丽的建议的支持，以接受皇家提升。

相关讨论

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

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

或

1
if (typeof value  !=="undefined" && value)
相关讨论

！检查空字符串(")、空、未定义、假以及数字0和NaN。比如，如果字符串为空，那么var name =""，那么console.log(!name)返回true。

1
2
3
function isEmpty(val){
  return !val;
}

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

或

根据你的问题域，你可以像!val或!!val那样使用。

相关讨论

你做得有点过头了。要检查变量是否没有给定值，只需要检查未定义和空值。

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

这是假设0、""和对象(甚至是空对象和数组)是有效的"值"。

这里是mine-如果值为空、未定义等或空(即只包含空格)，则返回true：

1
2
3
4
5
function stringIsEmpty(value) {

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

}

如果您喜欢纯javascript，请尝试以下操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
  /**
   * 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，请尝试：

1
_.isEmpty(value)
相关讨论

这种状况检查

1
2
3
if (!!foo) {
    //foo is defined
}

是你所需要的。

相关讨论

1
return val || 'Handle empty variable'

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

1
const res = val || 'default value'
相关讨论

检查默认值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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.

检查结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
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()来检查哪种类型的对象。

使用Instansof？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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]"
相关讨论

如果变量没有被声明，您将无法使用函数测试未定义的，因为您将得到一个错误。

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

如果没有声明foo，两者都将生成错误。

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

1
typeof foo !="undefined"

如果要测试是否已声明foo，并且它有一个值，则可以使用

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

1
2
3
4
5
6
7
8
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中：

1
2
3
4
5
6
7
8
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
}
相关讨论

我会留下一个我非常喜欢的注册解决方案：

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

1
2
3
4
5
6
7
8
9
10
11
12
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、""、[]、{}。
  • 假：true、false、1、0、-1、"foo"、[1, 2, 3]、{ foo: 1 }。
相关讨论

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

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

那么：isNullOrUndefined(this.yourVariableName)。

请注意：如下文所述，现在不推荐使用value === undefined || value === null。裁判。

相关讨论

它可能有用。

1
[null, undefined, ''].indexOf(document.DocumentNumberLabel) > -1
相关讨论

您可以使用下面的代码检查所有四(4)个验证条件，例如不为空、不为空、不为未定义、不为零，只使用此代码(！(！(variable)))在javascript和jquery中。

1
2
3
4
5
6
7
8
9
10
11
12
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);
    }
}

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

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

对于每一个来这里问类似问题的人来说，下面的问题非常有用，我在过去的几年里把它放在了我的图书馆里：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
(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));
1
2
3
function isEmpty(val){
    return !val;
}

但是这个解决方案设计过度，如果您以后不想为业务模型需求修改函数，那么直接在代码中使用它会更干净：

1
if(!val)...

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

1
2
3
4
5
6
7
8
9
10
11
12
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 translate函数translatelement是否存在。这相当于：

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

我想用？操作人员比较干净。

1
var ? function_if_exists() : function_if_doesnt_exist();

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

1
2
3
4
5
6
7
8
9
10
11
12
13
function checkup( t ){
  try{
    for(p in t){
      if( p.hasOwnProperty( t ) ){
        return true;
      }
    }
    return false;
  }catch(e){
    console.log("ERROR :"+e);
    return e;
  }
}

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

1
2
3
4
5
6
7
8
try{

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

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

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

相关讨论

对empty object {}、empty array []、null、undefined和blank string""进行功能检查。

1
2
3
4
5
6
7
8
9
10
11
12
13
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) -> true
val=[];
isEmpty(val) -> true
isEmpty(undefined) -> true
isEmpty(null) -> true
isEmpty("") -> true
isEmpty(false) -> false
isEmpty(0) -> false

可以直接使用相等运算符

1
2
3
4
5
6
7
8
9
    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.');
        }

演示@how to determine if variable is undefined or null using javascript

对于我的案件，我尝试了如果无效，"，！变量，但它不起作用。

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

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

如果状态变量中没有值(没有文本)，我试图将值"no value"设置为状态变量。

以下代码工作正常。

1
2
3
4
if(status == false)
{
   status='novalue';
}

当没有找到satus变量的文本时，上述代码将"novalue"分配给状态变量。

相关讨论