Is it possible to simplify the code like so:

if(arrayName.length > 0){   
    //or **if(arrayName.length)**
    //array contains elements 
}else{
   //array is empty
}

Simply relying on .length may not be reliable and could potentially lead to errors in certain browsers. A more robust alternative is:

if(array && array.length){   
   // array is not empty
} else {
   // array is empty
}

Alternatively, you can also use:

Object.keys(__array__).length

if(!arr[index]){
     // perform actions
}

Checking if the length of arrayName is greater than the specified index and if the value at that index is not null, then execute the code block inside the condition.

Simple and versatile method

To quickly determine if an array contains any falsy values (such as false, undefined, null, or empty strings), you can utilize the every() method in the following way:

array.every(function(item) {return !!item;}); // outputs true or false

For instance:

['abc', null, 123, {name: 'John'}].every(function(item) {return !!item;}); // returns false

['abc', '', 123, {name: 'John'}].every(function(item) {return !!item;}); // returns false

['abc', true, 123, {name: 'John'}].every(function(item) {return !!item;}); // returns true

If you wish to find the index of the first falsy value in the array, you can use this approach:

let falsyIdx; 

if (!['abc', true, 123, null, {name: 'John'}].every(function(item, index) {falsyIdx = index; return !!item;})) {
  console.log(falsyIdx);
} // prints 3

If you only need to check if a specific index in the array contains a falsy value, you can do so like this:

if (!!array[index]) {
  // array[index] is a valid value
}
else {
  // array[index] is a falsy value
}

if(typeof array ==='object' && array instanceof Array ){
   if(!array.length){
      print('empty Array')
   }else{
      print('not Empty Array')
   }

}else{
   print('Array is Null')
}

If by 'Null' you mean its elements are null or equal to '' , then you can check if the array is empty after filtering out all 'null' elements

if(!array.clean().length){return 'array is null'}

Make sure to add the Clean method before using it:

Array.prototype.clean=function(){return this.filter(function(element){return (typeof  element !=='undefined')&&(element!= null)&&(element!='')})}

When discussing the concept of "empty", it all comes down to interpretation.

If you try to access a property on an object that doesn't actually exist, the result will be undefined.

This is particularly noticeable when dealing with sparse arrays, where not every index between 0 and array.length-1 is occupied.

One way to handle this is by checking if array[index] === undefined.

However, it's important to note that a property index might exist with an assigned value of undefined. In such cases, you can use the in operator or hasOwnProperty method, as explained in How do I check if an object has a property in JavaScript?

index in array;
array.hasOwnProperty(index);

If you wish to treat properties with values of undefined or null as non-existent, you can employ loose comparisons like array[index] == undefined or array[index] == null.

In scenarios where the array is known to be non-sparse, you can compare index with array.length. Nonetheless, for added security, validating that index is indeed an array index would be advisable, as discussed in Check if property name is array index

If you're looking to improve your code, consider implementing a function like the one below:

function checkIfEmpty(array, i) {
   return !(array[i]);
}

You can use it like this:

if (checkIfEmpty(arrayName, indexVal)) {
   console.log('arrayName[' + indexVal + '] is empty');
}

Enforcing the use of the checkIfEmpty function can help catch mistakes like using undefined variables for arrayName or indexVal.

(It's always a good idea to be cautious when coding in JavaScript.)

If arrayName is not defined, an error will be thrown as shown below:

Uncaught ReferenceError: arrayName is not defined
    at <anonymous>:2:15
    at Object.InjectedScript._evaluateOn (<anonymous>:895:140)
    at Object.InjectedScript._evaluateAndWrap (<anonymous>:828:34)
    at Object.InjectedScript.evaluate (<anonymous>:694:21)

Similar consequences if indexVal is not defined.

An error occurs if the array or index values are missing.

With valid input, the function will only return true if arrayName[indexVal] is null, undefined, NaN, an empty string, 0, or false.

One important aspect that seems to have been overlooked by some is the possibility of having an "empty" array position within an array. Let's consider the following scenario:

let arr = [0, 1, 2, 3, 4, 5]

delete arr[3]

console.log(arr)      // [0, 1, 2, empty, 4, 5]

console.log(arr[3])   // undefined

In such cases, the common approach would be to check if the array element is undefined. I'm not certain if there are other methods available for this.

if (arr[index] === undefined) {
  // array element does not exist
}

New way of detecting: in operation

This question has been around for a decade now and surprisingly, no one has brought up this method yet - although some individuals have noticed the issue when utilizing the delete operator (for example, see here). This alternative solution may seem a bit counterintuitive, but the in operator, typically used in the 'object world', can also be applied to arrays (since array indexes can be treated as 'keys'...). This allows us to distinguish between an undefined array value and a value (or index) that has been deleted using delete.

if(index in arrayName) {
   // perform actions 
}

let arr = [0, 1, 2, 3, null, undefined, 6]

delete arr[2]; // deleting an element at index=2

if(2 in arr) console.log('You will not see this because idx 2 was deleted');
if(5 in arr) console.log('This is element arr[5]:', arr[5]);

// Displaying the entire array along with indexes greater than arr.length:
for(let i=0; i<=9; i++) {
  let val = (i in arr) ? arr[i] : 'empty'
  let bound = i<arr.length ? '' : '(out of range)'
  console.log(`${i} value: `, val, bound);
}

console.log('Please check the array below in the Chrome console (not in the SO snippet console)');
console.log('typeof arr:', typeof arr);
console.log(arr);

The Chrome console provides insights about the array in the snippet with the deleted index 2 - in reality, this index does not exist at all (!!!) (similar to removing a key from an object). Another interesting observation is that the array is seen as key-value pairs (even displaying the 'length' key). It is noteworthy that typeof arr returns Object (!!!), indicating that the delete and in operators function similarly to JS objects (the square brackets notation arr[idx] is akin to obj[key]) - this suggests that an array is essentially a specialized JS object at its core.

https://i.sstatic.net/ag8cr.png

To achieve a similar outcome without using delete, define the array as shown below

[0, 1,, 3, null, undefined, 6] // note the double comma: ",,"

Alright, let's start by exploring what happens when a value is missing in JavaScript arrays. For example, consider the following array:

const numbers = [1, 2, 3, 4, 5];

Now, let's check if the value 6 exists at index 5 or not:

numbers[5];

We would receive undefined as the result...

So, the recommended approach to check for undefined values is like this:

if("undefined" === typeof arrayName[index]) {
  //Value does not exist in the array
}

It's not advisable to use the following method in this scenario:

if(!arrayName[index]) {
  //Avoid using this method..
}

For instance, consider the following array:

const numbers = [0, 1, 2];

Now, if we do:

if(!numbers[0]) {
  //This condition will pass, as 0 is falsy in JavaScript
}

As demonstrated, even though 0 is present, it may not be recognized. There are a few other scenarios that may lead to similar issues and potentially impact your application, so caution is advised. Here are some of them:

1. undefined: when the value is not defined and is undefined
2. null: if a value is null, for instance, when a DOM element does not exist...
3. empty string: ''
4. 0: the number zero
5. NaN: not a number
6. false

Consider using this approach when dealing with a null value in array[index]

if (array[index] != null) 

When utilizing Lodash, you can achieve the following:

if(_.has(req,'documents')){
      if (req.documents.length)
      _.forEach(req.documents, function(document){
        records.push(document);
      });
} else {
}

if(_.has(req,'documents')) serves as a check to determine if our request object contains a property named documents. If this property exists, the subsequent if (req.documents.length) is used to verify that it is not an empty array, allowing for the execution of actions such as forEach.

To verify whether a variable has never been defined or if it has been deleted:

if(typeof variableName[index]==="undefined"){
     //the index does not exist in the variable
}

This method also applies to associative arrays and arrays where specific indexes have been deleted

To check if a variable has never been defined, been deleted, or holds a null or logically empty value (such as NaN, an empty string, or false):

if(typeof variableName[index]==="undefined"||variableName[index]){
     //the index is not defined or the value is empty
}

Encountered a similar issue while using laravel datatables. I had saved a JSON value named attributes in a log and needed to display a button based on whether this value was empty or not.

Unfortunately, datatables was interpreting the JSON as an array when empty and as an object when not empty. As a result, I came up with the following workaround:

render: function (data, type, full) {
    if (full.attributes.length !== 0) {
        // perform action
    }
}

Remember, objects do not have a length property.

In my opinion, this choice is suitable for individuals who favor declarative functional programming over imperative OOP or procedural programming. If you find yourself asking, "Are there values inside? (a truthy or falsy value)," you can utilize the .some method to check for values.

[].some(el => el || !el);

• While it may not be flawless, it eliminates the need for an additional function with similar logic, such as function isEmpty(arr) { ... }.
• It is more preferable to ask "Is it zero length?" when checking [].length, which could return 0 and pose risks in certain scenarios.
• Similarly, the comparison [].length > 0 raises the question "Is its length greater than zero?"

For more advanced examples:

[    ].some(el => el || !el); // false
[null].some(el => el || !el); // true
[1, 3].some(el => el || !el); // true

When an empty array is created, the values are not undefined, they are simply empty

var newArr = new Array(10); // (10) [empty × 10]

However, when you try to access an item by its index, you will receive undefined

newArr[0]; // undefined

Therefore, it is tricky to determine whether a value is undefined or empty by using === comparison

One way to address this is by using JSON.stringify, which replaces empty values with null in an entire array

JSON.stringify(newArr); // "[null,null,null,null,null,null,null,null,null,null]"
JSON.stringify(newArr[0]); // However, for a single item, it will still return undefined

To truly check for an empty value:

newArr[0] !== null && JSON.stringify(newArr.map(item => !item)).slice(1, -1).split(',')[0] === 'null'

1. Compare the item with null (it should not be equal)
2. Map the array, removing false and keeping existing values to ensure the stringified structure is comma-separated without redundant commas
3. Stringify the array
4. Remove the brackets from the string
5. Split the string into an array by commas
6. Compare with null