How can I check JavaScript arrays for empty strings?

You can check by looping through the array with a simple for, like this:

function NoneEmpty(arr) {
  for(var i=0; i<arr.length; i++) {
    if(arr[i] === "") return false;
  }
  return true;
}

You can give it a try here, the reason we're not using .indexOf() here is lack of support in IE, otherwise it'd be even simpler like this:

function NoneEmpty(arr) {
  return arr.indexOf("") === -1;
}

But alas, IE doesn't support this function on arrays, at least not yet.

You can try jQuery.inArray() function:

return jQuery.inArray("", my_arr)

Using a "higher order function" like filter instead of looping can sometimes make for faster, safer, and more readable code. Here, you could filter the array to remove items that are not the empty string, then check the length of the resultant array.

Basic JavaScript

var my_arr = ["", "hi", ""]

// only keep items that are the empty string
new_arr = my_arr.filter(function(item) {
  return item === ""
})

// if filtered array is not empty, there are empty strings
console.log(new_arr);
console.log(new_arr.length === 0);

Modern Javascript: One-liner

var my_arr = ["", "hi", ""]
var result = my_arr.filter(item => item === "").length === 0
console.log(result);

A note about performance

Looping is likely faster in this case, since you can stop looping as soon as you find an empty string. I might still choose to use filter for code succinctness and readability, but either strategy is defensible.

If you needed to loop over all the elements in the array, however-- perhaps to check if every item is the empty string-- filter would likely be much faster than a for loop!

Nowadays we can use Array.includes

my_arr.includes("")

Returns a Boolean

You could do a simple help method for this:

function hasEmptyValues(ary) {
    var l = ary.length,
        i = 0;

    for (i = 0; i < l; i += 1) {
        if (!ary[i]) {
            return false;
        }
    }

    return true;
}

//check for empty
var isEmpty = hasEmptyValues(myArray);

EDIT: This checks for false, undefined, NaN, null, "" and 0.

EDIT2: Misread the true/false expectation.

..fredrik

function containsEmpty(a) {
    return [].concat(a).sort().reverse().pop() === "";
}
alert(containsEmpty(['1','','qwerty','100'])); // true
alert(containsEmpty(['1','2','qwerty','100'])); // false

my_arr.includes("")

This returned undefined instead of a boolean value so here's an alternative.

function checkEmptyString(item){
     if (item.trim().length > 0) return false;
     else return true;
    };
    
function checkIfArrayContainsEmptyString(array) {
  const containsEmptyString = array.some(checkEmptyString);
  return containsEmptyString;
};
    
console.log(checkIfArrayContainsEmptyString(["","hey","","this","is","my","solution"]))
// *returns true*

console.log(checkIfArrayContainsEmptyString(["yay","it","works"]))
// *returns false*

yourArray.join('').length > 0

Join your array without any space in between and check for its length. If the length, turns out to be greater than zero that means array was not empty. If length is less than or equal to zero, then array was empty.

I see in your comments beneath the question that the code example you give is PHP, so I was wondering if you were actually going for the PHP one? In PHP it would be:

function hasEmpty($array)
{
  foreach($array as $bit)
  {
    if(empty($bit)) return true;
  }

  return false;
}

Otherwise if you actually did need JavaScript, I refer to Nick Craver's answer

Just do a len(my_arr[i]) == 0; inside a loop to check if string is empty or not.

You have to check in through the array of some functions.

if isEmptyValue is true that means the array has an empty string otherwise not.

const arr=['A','B','','D'];

const isEmptyValue = arr.some(item => item.trim() === '');

console.log(isEmptyValue)

const hasEmptyString = (arr) => arr.includes('');

var containsEmpty = !my_arr.some(function(e){return (!e || 0 === e.length);});

This checks for 0, false, undefined, "" and NaN. It's also a one liner and works for IE 9 and greater.

One line solution to check if string have empty element

let emptyStrings = strArray.filter(str => str.trim().length <= 0);

let strArray = ['str1', '', 'str2', ' ', 'str3', '    ']
let emptyStrings = strArray.filter(str => str.trim().length <= 0);
console.log(emptyStrings)

One line solution to get non-empty strings from an array

let nonEmptyStrings = strArray.filter(str => str.trim().length > 0);

let strArray = ['str1', '', 'str2', ' ', 'str3', '    ']
let nonEmptyStrings = strArray.filter(str => str.trim().length > 0);
console.log(nonEmptyStrings)

If you only care about empty strings then this will do it:

const arr = ["hi","hello","","jj"]
('' in arr) //returns false

the last line checks if an empty string was found in the array.

I don't know if this is the most performant way, but here's a one liner in ES2015+:

// true if not empty strings
// false if there are empty strings
my_arr.filter(x => x).length === my_arr.length

The .filter(x => x) will return all the elements of the array that are not empty nor undefined. You then compare the length of the original array. If they are different, that means that the array contains empty strings.

array.includes("") works just fine.

Let a = ["content1", "" , "content2"]; console.log(a.includes(""));

//Output in console true