How to check for an empty, undefined, or null string in JavaScript?

Sample query:

Is there a simple string.Empty available in JavaScript, or is it just a case of checking for ""?

How to check empty string in JavaScript?

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

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

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

How to check empty, undefined, or null string in JavaScript?

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

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 nullundefined0000""false.
  • It returns true for all string values other than the empty string (including strings like "0" and " ")

Code examples to check empty string in JavaScript:


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

if (!str.length) { ...


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


I use:

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

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


If one needs to detect not only empty but also blank strings, I’ll add to above answers:

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

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


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


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

Answer #2:

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

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.

Answer #3:

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



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

Answer #4:

You could also go with regular expressions:

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

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

Answer #5:

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;
        return false;

Answer #6:

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

Answer #7:

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'){
            return true;
        return false;
    }else if(typeof(data) === 'undefined'){
        return true;
        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

Hope you learned something from this post.

Follow Programming Articles for more!

About ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ

Linux and Python enthusiast, in love with open source since 2014, Writer at, India.

View all posts by ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ →