如何在JavaScript中检查empty / undefined / null字符串？

I saw this thread, but I didn't see a JavaScript specific example. Is there a simple string.Empty available in JavaScript, or is it just a case of checking for ""?

我看到了这个帖子,但我没有看到JavaScript特定的例子。是否有一个简单的string.Empty可用于JavaScript,还是只是检查“”的情况?

39 个解决方案

#1

If you just want to check whether there's any value, you can do

如果你只是想检查是否有任何价值,你可以这样做

if (strValue) {
    //do something
}

If you need to check specifically for an empty string over null, I would think checking against "" is your best bet, using the === operator (so that you know that it is, in fact, a string you're comparing against).

如果你需要专门检查null上的空字符串,我认为使用===运算符检查“”是最好的选择(这样你就知道它实际上是你正在比较的字符串)。

if (strValue === "") {
    //...
}

#2

For checking if a string is empty, null or undefined I use:

为了检查字符串是否为空,null或未定义,我使用:

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

For checking if a string is blank, null or undefined I use:

为了检查字符串是否为空,null或未定义,我使用:

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

For checking if a string is blank or contains only white-space:

用于检查字符串是空白还是仅包含空格:

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

#3

All the above are good but this will be even better. use !!(not not) operator.

以上所有都很好,但这会更好。使用!!(不是)运营商。

if(!!str){
some code here;
}

or use type casting:

或使用类型铸造:

if(Boolean(str)){
    codes here;
}

Both do the same function, type cast the variable to boolean, where str is a variable.
Returns false for null,undefined,0,000,"",false.
Returns true for string "0" and whitespace " ".

两者都执行相同的功能,将变量类型转换为boolean,其中str是变量。对于null,undefined,0,000,“”,false返回false。对于字符串“0”和空格“”,返回true。

#4

If you need to make sure that the string is not just a bunch of empty spaces (I'm assuming this is for form validation) you need to do a replace on the spaces.

如果你需要确保字符串不只是一堆空格(我假设这是用于表单验证),你需要对空格进行替换。

if(str.replace(/\s/g,"") == ""){
}

#5

The closest thing you can get to str.Empty (with the precondition that str is a String) is:

你可以得到str.Empty最接近的事情(str的前提条件是String)是:

if (!str.length) { ...

#6

I use :

我用 :

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

#7

Try:

if (str && str.trim().length) {  
    //...
}

#8

var s; // undefined
var s = ""; // ""
s.length // 0

There's nothing representing an empty string in JavaScript. Do a check against either length (if you know that the var will always be a string) or against ""

JavaScript中没有任何代表空字符串的内容。对任一长度进行检查(如果您知道var将始终为字符串)或针对“”

#9

I would not worry too much about the most efficient method. Use what is most clear to your intention. For me that's usually strVar == "".

我不会太担心最有效的方法。使用你的意图最明确的。对我而言,通常是strVar ==“”。

EDIT: per comment from Constantin, if strVar could some how end up containing an integer 0 value, then that would indeed be one of those intention-clarifying situations.

编辑:根据Constantin的评论,如果strVar可能会有一些结果包含整数0值,那么这确实是那些意图澄清情况之一。

#10

Function:

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;

附:在Javascript中,不要在返回后使用Line-Break;

#11

You can use lodash : _.isEmpty(value).

您可以使用lodash:_. isEmpty(value)。

It covers a lot of cases like {}, '', null, undefined etc.

它涵盖了很多案例,如{},'',null,undefined等。

But it always returns true for Number type of Javascript Primitive Data Types like _.isEmpty(10) or _.isEmpty(Number.MAX_VALUE) both returns true.

但它始终返回true,Javascript原始数据类型的数字类型,如_.isEmpty(10)或_.isEmpty(Number.MAX_VALUE)都返回true。

#12

you could also go with regexps:

你也可以使用正则表达式:

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

Checks for strings that are either empty or filled with whitespace.

检查空白或填充空格的字符串。

#13

1. check that var a; exist

检查var a;存在

2. trim out the false spaces in the value, then test for emptiness

   修剪掉值中的虚假空格,然后测试空虚

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

#14

A lot of answers, and a lot of different possibilities!

很多答案,以及很多不同的可能性!

Without a doubt for quick and simple implementation the winner is: if (!str.length) {...}

毫无疑问,快速和简单的实现赢家是:if(!str.length){...}

However, as many other examples are available. The best functional method to go about this, I would suggest:

但是,正如许多其他例子一样。最好的功能方法,我建议:

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

A bit excessive, I know.

我知道,有点过分了。

#15

Also, in case you consider a whitespace filled string as "empty". You can test it with this Regex:

此外,如果您将填充空格的字符串视为“空”。您可以使用此Regex进行测试:

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

#16

I usually use some thing like this,

我经常使用这样的东西,

if (!str.length) {
//do some thing
}

#17

I have not noticed an answer that takes into account the possibility of null characters in a string. For example, if we have a null character string:

我没有注意到一个考虑到字符串中空字符可能性的答案。例如,如果我们有一个空字符串:

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

To test its nullness one could do something like this:

要测试其null,可以执行以下操作:

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

It works on a null string, and on an empty string and it is accessible for all strings. In addition, it could be expanded to contain other JavaScript empty or whitespace characters (i.e. nonbreaking space, byte order mark, line/paragraph separator, etc.).

它适用于空字符串,并且在空字符串上,并且可以访问所有字符串。此外,它可以扩展为包含其他JavaScript空或空白字符(即不间断空格,字节顺序标记,行/段分隔符等)。

#18

If one needs to detect not only empty but also blank strings, I'll add to Goral's answer:

如果一个人不仅要检测空字符串还需要空白字符串,我将添加Goral的答案:

function isEmpty(s){
    return !s.length;    
}

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

#19

All these answers are nice.

所有这些答案都很好。

But I cannot be sure that variable is a string, doesn't contains only spaces (this is important for me), and can contain '0' (string).

但我不能确定变量是一个字符串,不包含空格(这对我来说很重要),并且可以包含'0'(字符串)。

My version:

function empty(str){
    return !str || !/[^\s]+/.test(str);
}

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

Sample on jsfiddle.

jsfiddle上的示例。

#20

I use a combination, fastest checks are first.

我使用组合,最快的检查是第一次。

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

#21

Ignoring whitespace strings, you could use this to check for null, empty and undefined :

忽略空白字符串,您可以使用它来检查null,empty和undefined:

var obj = {};
(!!obj.str) //returns false

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

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

Concise and it works for undefined properties, although it's not the most readable.

简洁,它适用于未定义的属性,虽然它不是最易读的。

#22

I did some research what happens if you pass a non-string and non-empty/null value to a tester function. As many knows, (0 == "") is true in javascript, but since 0 is a value and not empty or null, you may want to test for it.

我做了一些研究,如果将非字符串和非空/空值传递给测试器函数会发生什么。众所周知,(0 ==“”)在javascript中是正确的,但由于0是一个值而不是空或null,您可能想要测试它。

The following two functions return true only for undefined, null, empty/whitespace values and false for everything else, such as numbers, boolean, objects, expressions etc.

以下两个函数仅对undefined,null,empty / whitespace值返回true,对其他所有值返回false,如数字,布尔值,对象,表达式等。

function IsNullOrEmpty(value)
{
    return (value == null || value === "");
}
function IsNullOrWhiteSpace(value)
{
    return (value == null || !/\S/.test(value));
}

More complicated examples exists, but these are simple and give consistent results. There is no need to test for undefined, since it's included in (value == null) check. You may also mimic C# behaviour by adding them to String like this:

存在更复杂的例子,但这些例子很简单并且给出了一致的结果。没有必要测试undefined,因为它包含在(value == null)检查中。您也可以通过将它们添加到String来模仿C#行为,如下所示:

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

You do not want to put it in Strings prototype, because if the instance of the String-class is null, it will error:

您不希望将它放在Strings原型中,因为如果String类的实例为null,则会出错:

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

I tested with the following value array. You can loop it through to test your functions if in doubt.

我测试了以下值数组。如果有疑问,你可以循环测试你的功能。

// 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', '\n'],
    ['carriage return', '\r'],
    ['"\\r\\n"', '\r\n'],
    ['"\\n\\r"', '\n\r'],
    ['" \\t \\n "', ' \t \n '],
    ['" txt \\t test \\n"', ' txt \t test \n'],
    ['"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; } }]
];

#23

to check if is exactly an empty string:

检查是否完全是一个空字符串:

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

to check if it is an empty string OR a a logical equivalent for no-value (null, undefined, 0, NaN, false, ...):

检查它是否为空字符串或无值的逻辑等效项(null,undefined,0,NaN,false,...):

if(!val)...

#24

Meanwhile we can have one function that checks for all 'empties' like null, undefined, '', ' ', {}, []. So I just wrote this.

同时,我们可以使用一个函数来检查所有'空,',如null,undefined,'','',{},[]。所以我写了这个。

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

Use cases and results.

用例和结果。

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

#25

I usually use something like:

我通常使用类似的东西:

if (str == "") {
     //Do Something
}
else {
     //Do Something Else
}

#26

There's no isEmpty() method, you have to check for the type and the length:

没有isEmpty()方法,你必须检查类型和长度:

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

The type check is needed in order to avoid runtime errors when test is undefined or null.

当测试未定义或为null时,需要进行类型检查以避免运行时错误。

#27

Try this

   str.value.length == 0

#28

Don't assume that the variable you check is a string. Don't assume that if this var has a length, then it's a string.

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

The thing is: think carefully about what your app must do and can accept. Build something robust.

问题是:仔细考虑您的应用必须做什么并且可以接受的内容。建立强大的东西。

If your method / function should only process a non empty string then test if the argument is a non empty string and don't do some 'trick'.

如果你的方法/函数只应该处理一个非空字符串,那么测试参数是否为非空字符串并且不做一些“技巧”。

As an example of something that will explode if you follow some advices here not carefully.

作为一个例子,如果你在这里不小心遵循一些建议会爆炸。

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'

So, I'd stick with

所以,我坚持

if (myVar === '')
  ...

#29

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

this is also a generic way to check if field is empty.

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

#30

The underscore javascript library http://underscorejs.org/ provides a very useful _.isEmpty() function for checking for empty strings and other empty objects.

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

Reference: http://underscorejs.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 _.isEmpty(object)如果可枚举对象不包含任何值(没有可枚举的自身属性),则返回true。对于字符串和类似数组的对象,_. isEmpty检查length属性是否为0。

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

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

_.isEmpty({});
=> true

_。是空的({}); =>是的

Other very useful underscore functions include:
http://underscorejs.org/#isNull _.isNull(object)
http://underscorejs.org/#isUndefined _.isUndefined(value)
http://underscorejs.org/#has _.has(object, key)

其他非常有用的下划线函数包括:http://underscorejs.org/#isNull _.isNull(object)http://underscorejs.org/#isUndefined _.isUndefined(value)http://underscorejs.org/#has_ .has(对象,密钥)