如何检查javascript中的empty/undefined/null？


How to check empty/undefined/null string in JavaScript?

我看到了这个线程，但没有看到特定于javascript的示例。是否有一个简单的string.Empty在javascript中可用，或者只是一个检查""的案例？

相关讨论

如果你只想检查是否有价值，你可以

1
2
3
if (strValue) {
    //do something
}

如果您需要特别检查空字符串是否大于空值，我认为使用===运算符(以便您知道它实际上是您要比较的字符串)检查""是您的最佳选择。

1
2
3
if (strValue ==="") {
    //...
}
相关讨论

用于检查字符串是否为空、空或未定义，我使用：

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

用于检查字符串是否为空、空或未定义，我使用：

1
2
3
function isBlank(str) {
    return (!str || /^\s*$/.test(str));
}

用于检查字符串是否为空或仅包含空白：

1
2
3
String.prototype.isEmpty = function() {
    return (this.length === 0 || !this.trim());
};
相关讨论

以上都很好，但这会更好。使用!!运算符(非)。

1
2
3
if(!!str){
some code here;
}

或使用类型铸造：

1
2
3
if(Boolean(str)){
    codes here;
}

这两个函数的作用相同，类型将变量转换为布尔值，其中str是一个变量。返回null,undefined,0,000,"",false的false。返回字符串"0"和空格""的true。

相关讨论

如果您需要确保字符串不仅仅是一堆空格(我假设这是用于表单验证)，那么您需要对这些空格进行替换。

1
2
if(str.replace(/\s/g,"") ==""){
}
相关讨论

最接近str.Empty(前提是str是字符串)的是：

1
if (!str.length) { ...
相关讨论

我使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function empty(e) {
  switch (e) {
    case"":
    case 0:
    case"0":
    case null:
    case false:
    case typeof this =="undefined":
      return true;
    default:
      return false;
  }
}

empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
    return""
  })) // false
相关讨论

功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function is_empty(x)
{
   return (
        (typeof x == 'undefined')
                    ||
        (x == null)
                    ||
        (x == false)  //same as: !x
                    ||
        (x.length == 0)
                    ||
        (x =="")
                    ||
        (x.replace(/\s/g,"") =="")
                    ||
        (!/[^\s]/.test(x))
                    ||
        (/^\s*$/.test(x))
  );
}

p.s. In Javascript, don't use Line-Break after return;

相关讨论

尝试：

1
2
3
if (str && str.trim().length) {  
    //...
}
相关讨论

1
2
3
var s; // undefined
var s =""; //""
s.length // 0

在javascript中没有任何内容表示空字符串。对length或""进行检查(如果您知道var始终是字符串)。

我不会太担心最有效的方法。使用对你的意图最清楚的东西。对我来说，那通常是strVar ==""。

编辑：根据康斯坦丁的评论，如果strvar可以得到一个整数0的值，那么这确实是一个意图澄清的情况。

相关讨论

您可以使用木屑：_.isEmpty(值)。

它涉及的案件很多，如{}、''、null、undefined等。

但对于Number类型的javascript原始数据类型，如_.isEmpty(10)或_.isEmpty(Number.MAX_VALUE)总是返回true，两者都返回true。

您也可以使用regexps：

1
if((/^\s*$/).test(str)) { }

检查是否有空字符串或填充了空白字符串。

相关讨论

答案很多，可能性也很多！

毫无疑问，对于快速简单的实现，胜利者是：if (!str.length) {...}。

然而，还有许多其他的例子。为此，我建议最好的功能方法是：

1
2
3
4
5
6
7
8
9
10
11
function empty(str)
{
    if (typeof str == 'undefined' || !str || str.length === 0 || str ==="" || !/[^\s]/.test(str) || /^\s*$/.test(str) || str.replace(/\s/g,"") ==="")
    {
        return true;
    }
    else
    {
        return false;
    }
}

我知道有点过分了。

相关讨论

  • 检查是否存在var a;。

  • 去掉值中的false spaces，然后测试emptiness。

    1
    2
    3
    4
    if ((a)&&(a.trim()!=''))
    {
      // if variable a is not empty do this
    }

    • 另外，如果您认为空白填充字符串是"空的"。您可以用这个regex测试它：

    1
    !/\S/.test(string); // Returns true if blank.

    我通常用这样的东西，

    1
    2
    3
    if (!str.length) {
    //do some thing
    }
    相关讨论

    如果一个人不仅需要检测空字符串，还需要检测空字符串，我将在Goral的答案中添加：

    1
    2
    3
    4
    5
    6
    7
    function isEmpty(s){
        return !s.length;    
    }

    function isBlank(s){
        return isEmpty(s.trim());    
    }

    我没有注意到一个考虑到字符串中可能存在空字符的答案。例如，如果我们有一个空字符串：

    1
    2
    3
    4
    5
    var y ="\0"; // an empty string, but has a null character
    (y ==="") // false, testing against an empty string does not work
    (y.length === 0) // false
    (y) // true, this is also not expected
    (y.match(/^[\s]*$/)) // false, again not wanted

    为了测试它的空性，可以这样做：

    1
    2
    3
    4
    5
    String.prototype.isNull = function(){
      return Boolean(this.match(/^[\0]*$/));
    }
    ...
    "\0".isNull() // true

    它在空字符串和空字符串上工作，所有字符串都可以访问它。此外，它还可以扩展为包含其他javascript空字符或空白字符(即不间断空格、字节顺序标记、行/段落分隔符等)。

    相关讨论

    所有这些答案都很好。

    但我不能确定变量是一个字符串，不仅包含空格(这对我很重要)，而且可以包含"0"(字符串)。

    我的版本：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    function empty(str){
        return !str || !/[^\s]+/.test(str);
    }

    empty(null); // true
    empty(0); // true
    empty(7); // false
    empty(""); // true
    empty("0"); // false
    empty(" "); // true

    JSfiddle上的示例。

    相关讨论

    同时，我们可以有一个函数来检查所有的"空"如空、未定义、""、""、、[]。所以我写了这个。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    var isEmpty = function(data) {
        if(typeof(data) === 'object'){
            if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
                return true;
            }else if(!data){
                return true;
            }
            return false;
        }else if(typeof(data) === 'string'){
            if(!data.trim()){
                return true;
            }
            return false;
        }else if(typeof(data) === 'undefined'){
            return true;
        }else{
            return false;
        }
    }

    用例和结果。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    console.log(isEmpty()); // true
    console.log(isEmpty(null)); // true
    console.log(isEmpty('')); // true
    console.log(isEmpty('  ')); // true
    console.log(isEmpty(undefined)); // true
    console.log(isEmpty({})); // true
    console.log(isEmpty([])); // true
    console.log(isEmpty(0)); // false
    console.log(isEmpty('Hey')); // false

    要检查是否为空字符串，请执行以下操作：

    1
    if(val==="")...

    要检查它是空字符串还是无值的逻辑等价物(空、未定义、0、NaN、False…)：

    1
    if(!val)...

    忽略空白字符串，可以使用它检查是否为空、空和未定义：

    1
    2
    3
    4
    5
    6
    7
    8
    var obj = {};
    (!!obj.str) //returns false

    obj.str ="";
    (!!obj.str) //returns false

    obj.str = null;
    (!!obj.str) //returns false

    简洁，适用于未定义的属性，尽管它不是最可读的。

    我用组合，最快的检查是第一。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    function isBlank(pString){
        if (!pString || pString.length == 0) {
            return true;
        }
        // checks for a non-white space character
        // which I think [citation needed] is faster
        // than removing all the whitespace and checking
        // against an empty string
        return !/[^\s]+/.test(pString);
    }
    相关讨论

    我做了一些研究，如果您将一个非字符串和非空/空值传递给一个测试函数，会发生什么。很多人都知道，在javascript中，(0=")是真的，但是由于0是一个值，而不是空的或空的，所以您可能需要测试它。

    以下两个函数仅对未定义、空、空/空白值返回"真"，对其他所有值(如数字、布尔值、对象、表达式等)返回"假"。

    1
    2
    3
    4
    5
    6
    7
    8
    function IsNullOrEmpty(value)
    {
        return (value == null || value ==="");
    }
    function IsNullOrWhiteSpace(value)
    {
        return (value == null || !/\S/.test(value));
    }

    存在更复杂的例子，但这些例子很简单，并且给出了一致的结果。不需要测试未定义，因为它包含在(value==null)检查中。您还可以通过将它们添加到如下字符串来模拟C行为：

    1
    String.IsNullOrEmpty = function (value) { ... }

    您不想将其放入字符串原型中，因为如果字符串类的实例为空，则会出错：

    1
    2
    3
    4
    String.prototype.IsNullOrEmpty = function (value) { ... }
    var myvar = null;
    if (1 == 2) { myvar ="OK"; } // could be set
    myvar.IsNullOrEmpty(); // throws error

    我用以下值数组进行了测试。如果有疑问，您可以循环使用它来测试您的函数。

    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
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    // Helper items
    var MyClass = function (b) { this.a ="Hello World!"; this.b = b; };
    MyClass.prototype.hello = function () { if (this.b == null) { alert(this.a); } else { alert(this.b); } };
    var z;
    var arr = [
    // 0: Explanation for printing, 1: actual value
        ['undefined', undefined],
        ['(var) z', z],
        ['null', null],
        ['empty', ''],
        ['space', ' '],
        ['tab', '\t'],
        ['newline', '
    '    ],
        ['carriage return', '
    '    ],
        ['"\
    \
    "'    , '

    '    ],
        ['"\
    \
    "'    , '

    '    ],
        ['" \\t \
    "'    , ' \t
     '    ],
        ['" txt \\t test \
    "'    , ' txt \t test
    '    ],
        ['"txt"',"txt"],
        ['"undefined"', 'undefined'],
        ['"null"', 'null'],
        ['"0"', '0'],
        ['"1"', '1'],
        ['"1.5"', '1.5'],
        ['"1,5"', '1,5'], // valid number in some locales, not in js
        ['comma', ','],
        ['dot', '.'],
        ['".5"', '.5'],
        ['0', 0],
        ['0.0', 0.0],
        ['1', 1],
        ['1.5', 1.5],
        ['NaN', NaN],
        ['/\S/', /\S/],
        ['true', true],
        ['false', false],
        ['function, returns true', function () { return true; } ],
        ['function, returns false', function () { return false; } ],
        ['function, returns null', function () { return null; } ],
        ['function, returns string', function () { return"test"; } ],
        ['function, returns undefined', function () { } ],
        ['MyClass', MyClass],
        ['new MyClass', new MyClass()],
        ['empty object', {}],
        ['non-empty object', { a:"a", match:"bogus", test:"bogus"}],
        ['object with toString: string', { a:"a", match:"bogus", test:"bogus", toString: function () { return"test"; } }],
        ['object with toString: null', { a:"a", match:"bogus", test:"bogus", toString: function () { return null; } }]
    ];
    相关讨论

    我通常使用如下的方法：

    1
    2
    3
    4
    5
    6
    if (str =="") {
         //Do Something
    }
    else {
         //Do Something Else
    }

    没有isEmpty()方法，您必须检查类型和长度：

    1
    2
    if (typeof test === 'string' && test.length === 0){
      ...

    当test是undefined或null时，为了避免运行时错误，需要进行类型检查。

    试试这个

    1
    str.value.length == 0
    相关讨论

    不要假设您检查的变量是字符串。不要假设这个变量有一个长度，那么它是一个字符串。

    问题是：仔细考虑你的应用程序必须做什么并且可以接受。建立一个强大的东西。

    如果方法/函数只应处理非空字符串，则测试参数是否为非空字符串，并且不执行某些"技巧"。

    作为一个例子，如果你不小心遵循这里的一些建议，就会发生爆炸。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    var getLastChar = function (str) {
     if (str.length > 0)
       return str.charAt(str.length - 1)
    }

    getLastChar('hello')
    =>"o"

    getLastChar([0,1,2,3])
    => TypeError: Object [object Array] has no method 'charAt'
    </wyn>

    所以，我会坚持

    1
    2
    3
    if (myVar === '')
      ...
    </wyn>

    您可以很容易地将它添加到javascript中的本机字符串对象中，并反复使用它…如果您想检查''空字符串，下面的代码可以为您完成这项工作：

    1
    2
    3
    String.prototype.isEmpty = String.prototype.isEmpty || function() {
      return !(!!this.length);
    }

    否则，如果您想用空格检查''空字符串和' '，只需添加trim()，如下面的代码：

    1
    2
    3
    String.prototype.isEmpty = String.prototype.isEmpty || function() {
       return !(!!this.trim().length);
    }

    你可以这样称呼它：

    1
    2
    ''.isEmpty(); //return true
    'alireza'.isEmpty(); //return false

    您可以验证以下方法并了解其区别。

    1
    2
    3
    4
    5
    6
    7
    8
    var j = undefined;
    console.log((typeof j == 'undefined') ?"true":"false");
    var j = null;
    console.log((j == null) ?"true":"false");
    var j ="";
    console.log((!j) ?"true":"false");
    var j ="Hi";
    console.log((!j) ?"true":"false");

    下划线javascript库http://underlinejs.org/提供了一个非常有用的_.isEmpty()函数，用于检查空字符串和其他空对象。

    参考：http://underlinejs.org/isEmpty

    isEmpty _.isEmpty(object)
    Returns true if an enumerable object contains no values (no enumerable own-properties). For strings and array-like objects _.isEmpty checks if the length property is 0.

    _.isEmpty([1, 2, 3]);
    => false

    _.isEmpty({});
    => true

    其他非常有用的下划线函数包括：http://underlinejs.org/isnull _.isNull(object)http://underlinejs.org/isundefined _.isUndefined(value)。http://underlinejs.org/has _.has(object, key)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    function tell()
    {
    var pass = document.getElementById('pasword').value;
    var plen = pass.length;

    now you can check if your string is empty as like
    if(plen==0)
    {
             alert('empty');
    }
    else
    {
       alert('you entered something');
    }
    }


    <input type='text' id='pasword' />

    这也是检查字段是否为空的通用方法。

    您也应该经常检查类型，因为JavaScript是一种鸭式语言，所以您可能不知道数据在处理过程中是何时以及如何更改的。所以，下面是更好的解决方案：

    1
    2
    3
    4
    var str ="";
    if (str ==="") {
        //...
    }

    我喜欢用非空白测试代替空白测试

    1
    2
    3
    function isNotBlank(str) {
       return (str && /^\s*$/.test(str));
    }

    检查一下你是否试图传递一个未定义的术语也是个好主意。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    function TestMe() {
      if((typeof str != 'undefined') && str) {
        alert(str);
      }
     };

    TestMe();

    var str = 'hello';

    TestMe();

    我通常会遇到这样的情况：当对象实例的字符串属性不为空时，我想做一些事情。很好，但属性并不总是存在。

    另一种方法，但我相信布克斯的回答是最好的。

    1
    2
    3
    4
    5
       var myString = 'hello';
        if(myString.charAt(0)){
        alert('no empty');
        }
        alert('empty');

    到目前为止，还没有像string.empty这样的直接方法来检查字符串是否为空。但是在代码中，您可以使用包装器检查空字符串，例如：

    1
    2
    3
    4
    5
    6
    7
    8
    // considering the variable in which your string is saved is named str.
    if(str !== null || str!== undefined){
      if (str.length>0) {

      // Your code here which you want to run if the string is not empty.

      }
    }

    使用这个，您还可以确保字符串没有被定义或者也是空的。记住，未定义、空和空是三种不同的东西。

    相关讨论

    1
    2
    3
    4
    5
    6
    var x =" ";
    var patt = /^\s*$/g;
    isBlank = patt.test(x);
    alert(isBlank);// is it blank or not??
    x=x.replace(/\s*/g,"");// another way of replacing blanks with""
    if (x===""){alert("ya it is blank")}
    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
    <html>
    <head>
    <script lang="javascript">

    function nullcheck()
    {
    var n="fdgdfg";
    var e = n.length;
    if(e== 0)
    {

        return true;
    }
    else
    {
        alert("sucess");
        return false;
    }
    }



    </head>
    <body>
    <button type="submit" value="add" onclick="nullcheck()"></button>
    </body>
    </html>

    检查是否为空：

    1
    2
    3
    var str ="Hello World!";
    var n = str.length;
    if(n === ''){alert("THE STRING str is EMPTY");}

    检查它是否为空

    1
    2
    3
    var str ="Hello World!";
    var n = str.length;
    if(n != ''){alert("THE STRING str isn't EMPTY");}
    相关讨论