javascript - js判断对象类型 - 判断函数




有没有一个标准函数来检查JavaScript中的空,未定义或空白变量? (18)

是否有通用JavaScript函数检查变量是否有值并确保它不是undefined或为null ? 我有这个代码,但我不确定它是否涵盖所有情况:

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

检查默认值

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函数()来检查哪个类型的对象。

使用instanof«

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

检查空字符串(“”),null,undefined,false和数字0和NaN。 假如一个字符串是空的var name = ""那么console.log(!name)返回true

function isEmpty(val){
  return !val;
}

如果val空,null,undefined,false,数字0或NaN,则此函数将返回true。


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

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

这假定为0"" ,并且对象(甚至是空对象和数组)是有效的“值”。


在多个值的情况下,只需在每个值之间放置“&&”即可。

if( var1 && var2 && var3) {
  //to do...
}

如果变量没有被声明,你将无法使用函数测试undefined,因为你会得到一个错误。

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

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

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

typeof foo != "undefined"

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

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

对于我的情况,我试着用空,'',!变量,但它没有奏效。

看到我的代码如下从html字段中获取文本

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

如果状态变量中没有值(无文本),我试图将值'novalue'设置为状态变量。

下面的代码工作。

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

当没有为satus变量找到文本时,上面的代码将状态变量赋值为“novalue”


您可以使用:

If子句验证字符串或值是否为空。 喜欢这个:

if (someVar.value) 
{
  //its not emppty
}
else
{
  //Its empty
}

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

<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 @ 如何使用JavaScript确定变量是未定义的还是null


我知道这是一个古老的问题,但这是最安全的检查,我没有看到它在这里发布就像这样:

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

它将涵盖价值从未定义的情况,以及以下任何一种情况:

  • 空值
  • 未定义(未定义的值与从未定义的参数不同)
  • 0
  • “”(空字符串)
  • 为NaN

PS不需要在typeof值中严格相等!='undefined'


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

var ? function_if_exists() : function_if_doesnt_exist();

此函数检查empty object {}empty array []nullundefinedblank 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) - > true
VAL = [];
isEmpty(val) - > true
isEmpty(未定义) - > true
isEmpty(null) - > true
isEmpty(“”) - > true
isEmpty(false) - > false
isEmpty(0) - > false


虽然oldie,忘记是他们应该包装他们的代码块,然后捕获错误,然后测试...

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

所以,你真的不需要事先检查潜在的问题,你只需要抓住它,然后处理它想要的。


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

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

这是一个非常简单的。

if(data) {
  //Comes inside only if the data is not empty and not null 
}

这里是我的 - 如果值为null,未定义等或空白(即只包含空格),则返回true:

function stringIsEmpty(value) {

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

}

// value is undefined or null
return value === undefined || value === null;

JavaScript忍者可以使用==运算符:

return value == null;

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

这将返回true

undefined  // Because undefined == null

null

[]

""

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

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

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

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

这永远不会抛出一个错误。 如果myObjectchildmyValue为null,那么myNewValue将为null。 没有错误会被抛出







undefined