ChatGPT解决这个技术问题 Extra ChatGPT

How can I check for an empty/undefined/null string in JavaScript?

I saw this question, 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 ""?

just FYI, i think the most useful APIs for the String class are at Mozilla and javascript kit. [elated.com](elated.com/articles/working-with-strings ) has a tutorial on all of String's properties, methods,... Please note: the Mozilla link has been updated to developer.mozilla.org/en/JavaScript/Reference/Global_Objects/…
It would help greatly if the requirement was clearly specified. For what values should isEmpty return true? Checking for "" infers that it should only return true if the value is Type string and length 0. Many answers here assume it should also return true for some or all falsey values.
str.length > -1
I completely agree with @RobG, this question is badly defined. Why on earth would you consider null or undefined empty? An empty string is an empty string, it is not null or undefined

F
Flimm

If you just want to check whether there's a truthy 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).

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

Testing the length property may actually be faster than testing the string against "", because the interpreter won't have to create a String object from the string literal.
@Vincent doing some naïve profiling in Chrome developer tools, testing === '' vs .length didn't show any discernible improvement (and using .length only works if you can assume that you have a string)
@bdukes when you start to care about that kind of micro-optimizations, I don't think Chrome is the browser where you are having most of your performance problems...
Just to note, if your definition of "empty string" includes whitespace, then this solution is not appropriate. A string of 1 or more spaces returns true above. If you are using JQuery you can simply use this: if ($.trim(ref).length === 0) - as per this answer to a similar question: stackoverflow.com/questions/2031085/…
As expected .length > 0 is actually much faster than comparing to a string literal! Check out this jsPerf
j
jhpg

For checking if a variable is falsey or if it has length attribute equal to zero (which for a string, means it is empty), I use:

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

(Note that strings aren't the only variables with a length attribute, arrays have them as well, for example.)

Alternativaly, you can use the (not so) newly optional chaining and arrow functions to simplify:

const isEmpty = (str) => (!str?.length);

It will check the length, returning undefined in case of a nullish value, without throwing an error. In the case of an empty value, zero is falsy and the result is still valid.

For checking if a variable is falsey or if the string only contains whitespace or is empty, I use:

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

If you want, you can monkey-patch the String prototype like this:

String.prototype.isEmpty = function() {
    // This doesn't work the same way as the isEmpty function used 
    // in the first example, it will return true for strings containing only whitespace
    return (this.length === 0 || !this.trim());
};
console.log("example".isEmpty());

Note that monkey-patching built-in types are controversial, as it can break code that depends on the existing structure of built-in types, for whatever reason.


why 0 === str.length instead of str.length === 0 ?
@Vincent Conditions are often written like this if (variable == constant value) and if you forget an '=' then you're assigning the constant value to the variable instead of testing. The code will still work as you can assign variable in a if. So a safer way to write this condition is to reverse the constant value and the variable. This way when you test your code you'll see an error (Invalid lef-hand side in assignment). You can also use something like JSHint to disallow assignment in conditions and be warned when you write one.
/^\s*$/.test(str) can be replaced with str.trim().length === 0
@Vincent this is also called "Yoda Conditions", like if blue is the sky. See dodgycoder.net/2011/11/yoda-conditions-pokemon-exception.html
It isn't really a good idea to be extending native prototypes though, it is generally considered a bad practice that a lot of people just recommend against doing so entirely as there are safer ways that are just as good. There is a SO discussion on the topic here, but every JS programming book I've read has strongly recommended against it. For OPs problem I usually just do if (!str) { // i am sure str is empty null or undefined here if I'm sure it won't be another data type }
F
Flimm

All the previous answers are good, but this will be even better. Use dual NOT operators (!!):

if (!!str) {
    // Some code here
}

Or use type casting:

if (Boolean(str)) {
    // Code here
}

Both do the same function. Typecast the variable to Boolean, where str is a variable.

It returns false for null, undefined, 0, 000, "", false.

It returns true for all string values other than the empty string (including strings like "0" and " ")


Is there any difference between the behavior of if(str) and if(!!str)?
@PeterOlson if you are trying to save a variable as a boolean that checks multiple strings for content then you would want to do this.. aka var any = (!!str1 && !!str2 && !!str3) handling if there is a number in there as well
This is the solution I always use. !!str.trim() to make sure the string is not made of whitespaces only.
Not not looks like a hack, Boolean(str) is a lot more readable and less "wtfish".
This is simply useless in a if, it converts falsy values to false and truthy values to true. A if block either executes or not based on wether the expression is truthy, there is no point adding !!
K
Kick Buttowski

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

if (!str.length) { ...

Wouldn't that throw an exception is str is null?
@PicMickael Yes! So would str.Empty.
Note that strings aren't the only type of variable that have a length attribute. Arrays do as well.
S
Sugendran

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,"") == ""){
}

But does the job if what you actually want to test for is a string with non-space content. Is there a less-expensive way to test this?
How about the length property?
Instead of removing all the spaces, why not just check if there's a non-space? Has 2 advantages that it can bail out early if there is a non-space character, and it doesn't have return a new string which you then check against. if(str.match(/\S/g)){}
@Mark FYI, you wouldn't need the global modifier, since the match of the first occurrence of a non-space character would mean the string is not empty: str.match(/\S/)
Perhaps /\S/.test(str) is better than str.match(/\S/) because it doesn't bother with returning an array of matched results (might be micro performance gain there). Also, when just testing a string against a regexp, use the RegExp .test() method to better convey that intent.
S
Scotty Jamison

I use:

function empty(e) {
  switch (e) {
    case "":
    case 0:
    case "0":
    case null:
    case false:
    case undefined:
      return true;
    default:
      return false;
  }
}

empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
    return ""
})) // false

This solution is more language agnostic. The only JavaScript feature it relies on is typeof. So it is a good example of a solution you can use when you don't trust the implementations in different browsers and don't have time to grab a better solution. (IE, no internet access). It's something like a proof. Not the cleanest but you can be sure it will work without knowing too much about JavaScript.
I'd go even a bit further, and nail it with a === operator for the undefined case. Otherwise it's just simply the perfect answer.
The typeof in the switch did not work for me. I added a if (typeof e == "undefined") test and that works. Why?
@Lucas Because this was a typo or an oversight. Your modification is the correct approach. (the original refers to the context of the empty function, not the e parameter, which is what the function is supposed to check)
case typeof(e) == "undefined": is wrong; that matches an e of false, not of undefined. Apparently this was a suggested edit which got approved. The original case typeof this == "undefined": still doesn’t make any sense. There’s also no reason to consider false, 0, and "0" “empty”.
K
Kamil Kiełczewski

Performance

I perform tests on macOS v10.13.6 (High Sierra) for 18 chosen solutions. Solutions works slightly different (for corner-case input data) which was presented in the snippet below.

Conclusions

the simple solutions based on !str,==,=== and length are fast for all browsers (A,B,C,G,I,J)

the solutions based on the regular expression (test,replace) and charAt are slowest for all browsers (H,L,M,P)

the solutions marked as fastest was fastest only for one test run - but in many runs it changes inside 'fast' solutions group

https://i.stack.imgur.com/bFeGV.png

Details

In the below snippet I compare results of chosen 18 methods by use different input parameters

"" "a" " "- empty string, string with letter and string with space

[] {} f- array, object and function

0 1 NaN Infinity - numbers

true false - Boolean

null undefined

Not all tested methods support all input cases.

function A(str) { let r=1; if (!str) r=0; return r; } function B(str) { let r=1; if (str == "") r=0; return r; } function C(str) { let r=1; if (str === "") r=0; return r; } function D(str) { let r=1; if(!str || 0 === str.length) r=0; return r; } function E(str) { let r=1; if(!str || /^\s*$/.test(str)) r=0; return r; } function F(str) { let r=1; if(!Boolean(str)) r=0; return r; } function G(str) { let r=1; if(! ((typeof str != 'undefined') && str) ) r=0; return r; } function H(str) { let r=1; if(!/\S/.test(str)) r=0; return r; } function I(str) { let r=1; if (!str.length) r=0; return r; } function J(str) { let r=1; if(str.length <= 0) r=0; return r; } function K(str) { let r=1; if(str.length === 0 || !str.trim()) r=0; return r; } function L(str) { let r=1; if ( str.replace(/\s/g,"") == "") r=0; return r; } function M(str) { let r=1; if((/^\s*$/).test(str)) r=0; return r; } function N(str) { let r=1; if(!str || !str.trim().length) r=0; return r; } function O(str) { let r=1; if(!str || !str.trim()) r=0; return r; } function P(str) { let r=1; if(!str.charAt(0)) r=0; return r; } function Q(str) { let r=1; if(!str || (str.trim()=='')) r=0; return r; } function R(str) { let r=1; if (typeof str == 'undefined' || !str || str.length === 0 || str === "" || !/[^\s]/.test(str) || /^\s*$/.test(str) || str.replace(/\s/g,"") === "") r=0; return r; } // --- TEST --- console.log( ' "" "a" " " [] {} 0 1 NaN Infinity f true false null undefined '); let log1 = (s,f)=> console.log(`${s}: ${f("")} ${f("a")} ${f(" ")} ${f([])} ${f({})} ${f(0)} ${f(1)} ${f(NaN)} ${f(Infinity)} ${f(f)} ${f(true)} ${f(false)} ${f(null)} ${f(undefined)}`); let log2 = (s,f)=> console.log(`${s}: ${f("")} ${f("a")} ${f(" ")} ${f([])} ${f({})} ${f(0)} ${f(1)} ${f(NaN)} ${f(Infinity)} ${f(f)} ${f(true)} ${f(false)}`); let log3 = (s,f)=> console.log(`${s}: ${f("")} ${f("a")} ${f(" ")}`); log1('A', A); log1('B', B); log1('C', C); log1('D', D); log1('E', E); log1('F', F); log1('G', G); log1('H', H); log2('I', I); log2('J', J); log3('K', K); log3('L', L); log3('M', M); log3('N', N); log3('O', O); log3('P', P); log3('Q', Q); log3('R', R);

And then for all methods I perform speed test case str = "" for browsers Chrome v78.0.0, Safari v13.0.4, and Firefox v71.0.0 - you can run tests on your machine here

https://i.stack.imgur.com/IxaPG.png


Kind of misleading since it combines trim solutions with no-trim solutions.
P
Peter Mortensen

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

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

But it always returns true for Number type of JavaScript primitive data types like _.isEmpty(10) or _.isEmpty(Number.MAX_VALUE) both returns true.


_.isEmpty(" "); // => false
@Erich Because " " is not empty. _.isEmpty(""); returns true.
quite true - i mentioned this because a few of the other answers on here imply form validation and checking if a string consists of only whitespace, and this single lodash function by itself will not solve that problem.
T
T.Todua

Very generic "All-In-One" Function (not recommended though):

function is_empty(x)
{
    return (                                                           //don't put newline after return
        (typeof x == 'undefined')
              ||
        (x == null)
              ||
        (x == false)        //same as: !x
              ||
        (x.length == 0)
              ||
        (x == 0)            // note this line, you might not need this. 
              ||
        (x == "")
              ||
        (x.replace(/\s/g,"") == "")
              ||
        (!/[^\s]/.test(x))
              ||
        (/^\s*$/.test(x))
    );
}

However, I don't recommend to use that, because your target variable should be of specific type (i.e. string, or numeric, or object?), so apply the checks that are relative to that variable.


Any chance you could explain what each check is doing? :)
-1 They are testing for different things. It makes no sense to put them all into one if statement.
typeof MyVariable == 'undefined' doesn't discern between an initialized variable with an undefined value and an undeclared variable unless the variable was initially declared and initialized to null. Checking the length property causes the string primitive to be wrapped in a string object.
c
cllpse
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 ""


I don't understand this sentence: There's nothing representing an empty string in JavaScript. . What about "", doesn't that represent an empty string?
a
afuzzyllama

Try:

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

str.trim().length will do faster than str.trim(), by around 1% according to my own testing result.
OP is looking to test for empty string, undefined, or null. This is testing for a string that is not any of those conditions. He didn't say anything about whitespace only strings either. You can test for OP's conditions with just this, as long as you are sure no other data types are stored in the variable: if (!str) { ... }
P
Peter Mortensen

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 == "".

As per the 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.


Bad idea. You'll get true if strVar is accidentally assigned 0.
I agree that making your intention clear is more important than any micro-optimizations other methods might yield, but using the strict comparison operator === would be better. It only returns true if strVar is an empty string.
The check fails if undefined. So if(str) works better
@ValentinHeinitz if str were assigned a falsey value of 0 or "0", if(str) would falsely report true. The best approach is if(str === ""). It's simple and it will never fail.
P
Peter Mortensen

You could also go with regular expressions:

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

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


It works, but it's also horribly expensive ops-wise. Good if you just want to check one or two things, not a large set.
P
Praveen M P

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

Without a doubt for quick and simple implementation the winner is: 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.


Checking for undefined would need to be moved to first in the checks, or undefined items will throw exceptions on the earlier checks.
Completely agree! NICE CATCH. I will edit my above answer!
str.length === 0 returns true for any function that has no formal parameters.
str.length === 0 || str === "" both would do the same task.
K
Kruti Patel

check that var a; exist trim out the false spaces in the value, then test for emptiness if ((a)&&(a.trim()!='')) { // if variable a is not empty do this }


The string " " is not empty, but it would be considered empty by this condition.
P
Peter Mortensen

I usually use something like this,

if (!str.length) {
    // Do something
}

Fastest if you know that the variable is a string. Throws an error if the variable is undefined.
@AdrianHope-Bailie why would you test an undefined variable?
@AbimaelMartell Why not? You have a variable that either you declared or that was passed to you from some scope you have no control over such as in a response from a method or API call. You can assume it contains a value and use the check above but if it is not defined or is null you will get an error. var test = null; if(!test.length){alert("adrian is wrong");}
OP was asking for "how to check for an empty string", un undefined variable is not an empty string. Anyway you could check typeof variable != "undefined" before checking if is empty.
P
Peter Mortensen

Also, in case you consider a whitespace filled string as "empty".

You can test it with this regular expression:

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

J
Josef.B

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

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

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

P
Peter Mortensen

Starting with:

return (!value || value == undefined || value == "" || value.length == 0);

Looking at the last condition, if value == "", its length must be 0. Therefore drop it:

return (!value || value == undefined || value == "");

But wait! In JavaScript, an empty string is false. Therefore, drop value == "":

return (!value || value == undefined);

And !undefined is true, so that check isn't needed. So we have:

return (!value);

And we don't need parentheses:

return !value

what happens if value = false or value = 0. will you return the correct response according to the question?
W
Will

I use a combination, and the fastest checks are first.

function isBlank(pString) {
    if (!pString) {
        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);
}

Just wondering if you could explain when the length check would be necessary? Wouldn't !pString catch anything that was null/empty string? This seems to work. var test=''; if (!test) alert('empty');
I didn't see this comment until a decade later. But yes, you're right, I'll update. :)
Combining our knowledge 1 decade at a time :)
@Nicholi see you in 2031!
B
Bikush

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:

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


Interesting analysis. I don't think this would be relevant in 99.9% of cases. BUT I recently found that MySQL evaluates a column to "null" if (and only if) that column contains the null character ("\0"). Oracle on the other hand would not evaluate "\0" as being null, preferring to treat it as a string of length 1 (where that one character is the null character). This could cause confusion if not dealt with properly, because many web-developers do work with a back-end database, which might pass through different types of "null" values. It should be at the back of every developer's mind.
I
Imran Ahmad

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

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

P
Peter Mortensen

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

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.

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:

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:

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 JavaScript
    ['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; } }]
];

If you simply stop using == and use ===, then this solves the problem if(s === "").
P
Peter Mortensen

I didn't see a good answer here (at least not an answer that fits for me)

So I decided to answer myself:

value === undefined || value === null || value === "";

You need to start checking if it's undefined. Otherwise your method can explode, and then you can check if it equals null or is equal to an empty string.

You cannot have !! or only if(value) since if you check 0 it's going to give you a false answer (0 is false).

With that said, wrap it up in a method like:

public static isEmpty(value: any): boolean { return value === undefined || value === null || value === ""; }

PS.: You don't need to check typeof, since it would explode and throw even before it enters the method


Probably better use Boolean(value) construct that treats undefined and null values (and also 0, -0, false, NaN) as false. See stackoverflow.com/questions/856324/…
s
sean

Trimming whitespace with the null-coalescing operator:

if (!str?.trim()) {
  // do something...
}

It looks cool but str.trim() is sufficient. One should never overcomplicate things IMO.
Just throwing it out for those people who might need it. ?. couldn't be less complicated. .trim() would throw an error if str is nullish.
C
CroMagnon

Try this:

export const isEmpty = string => (!string || !string.length);

P
Peter Mortensen

All these answers are nice.

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

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.


Huh? If you are expecting a string, empty(0) and empty(7) should return the same value.
In my particular case - empty("0") must return false (because that is a not empty string), but empty(0) must return true because it is empty :)
But 0 isn't empty! It's a number, and numbers can't be full or empty. Of course, it's your function and so must satisfy your requirements, but empty is a misleading name in this case.
I think that name empty is good. In php docs for empty function: Returns FALSE if var exists and has a non-empty, non-zero value. Otherwise returns TRUE. The difference between PHP and this function - that string '0' will be not identified as empty.
As I say, it's your function: call it what you want. But empty is an inaccurate and misleading name. It's interesting that PHP also has a poorly-named empty function, but PHP's failings don't have anything to do with JavaScript.
I
Ibraheem
if ((str?.trim()?.length || 0) > 0) {
   // str must not be any of:
   // undefined
   // null
   // ""
   // " " or just whitespace
}

Update: Since this answer is getting popular I thought I'd write a function form too:

const isNotNilOrWhitespace = input => (input?.trim()?.length || 0) > 0;

const isNilOrWhitespace = input => (input?.trim()?.length || 0) === 0;

could you please give more explanation?
A
Agustí Sánchez

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

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

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


I'm pretty sure test === "" is equivalent, and it's shorter.
P
Peter Mortensen

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

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

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

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

It is concise and it works for undefined properties, although it's not the most readable.


You are checking for truthiness, here, which is bit more complicated than merely checking for empty strings, undefined or null