Count objects in array ignoring null

Question

I'm very junior, excuse me if it isn't an appropriate.

Trying to count the objects in an array, ignoring null. This is my code so far:

    function countTheObjects (arr) {

        let count = 0;

          for (let i = 0; i < arr.length; i++) {
             if (typeof arr[i] === 'object') {
               count++;
             }
             if (arr[i] === null) {
               count--;
             }


           }
         return count;
        }

What am I doing wrong?

Edit:

All these codes you guys have given me return exactly the same error mine does. These are the tests the code has to pass:

describe('countTheObjects', function () {
  it('returns the count of objects inside an array of random data types', function () {
    expect(countTheObjects([])).to.equal(0);
    expect(countTheObjects([1, 3, 4, 5])).to.equal(0);
    expect(countTheObjects([1, 3, 4, 5, 'foo'])).to.equal(0);
    expect(countTheObjects([1, 3, 4, 5, {}, {}, {}, 'foo'])).to.equal(3);
    expect(countTheObjects([1, [], 3, 4, 5, {}, {}, {}, 'foo'])).to.equal(3);
    expect(countTheObjects([1, [], null, 3, 4, 5, {}, {}, {}, 'foo'])).to.equal(3);
    expect(countTheObjects([1, {}, [], null, null, 'foo', 3, 4, 5, {}, {}, {}, 'foo'])).to.equal(4);
  });
});

Answer 1

Your code is wrong because typeof null === "object"

function countTheObjects (arr) {
  let count = 0;
  
  arr.forEach(e => {
    if (typeof e === "object" && e !== null) {
      count++;
    }
  });
  
  return count;
}
    
    
alert(countTheObjects([
  1, 2, 3, null, null, 5, 6, null, {}, {}, {}
]));    

Answer 2

Run this:

let arr = []
console.log(typeof arr) // 'object'

Your test expectations are wrong.

Array has typeof 'object' in Javascript.

If you want to make sure arrays are not counted, use Array.isArray(arr). You can also simplify your code considerably using instanceof instead of typeof:

function countTheObjects(arr) {
  let count = 0;
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] instanceof Object && !Array.isArray(arr[i])) {
      count++;
    }
  }
  return count;
}

console.log(countTheObjects([]) === 0);
console.log(countTheObjects([1, 3, 4, 5]) === 0);
console.log(countTheObjects([1, 3, 4, 5, 'foo']) === 0);
console.log(countTheObjects([1, 3, 4, 5, {}, {}, {}, 'foo']) === 3);
console.log(countTheObjects([1, [], 3, 4, 5, {}, {}, {}, 'foo']) === 3);
console.log(countTheObjects([1, [], null, 3, 4, 5, {}, {}, {}, 'foo']) === 3);
console.log(countTheObjects([1, {}, [], null, null, 'foo', 3, 4, 5, {}, {}, {}, 'foo']) === 4);

Answer 3

• You don't need to decrease the count when an element is null.
• Check for !== null && typeof === "object".
• null is a primitive, however in Javascript typeof null === 'object'.

function countTheObjects(arr) {
  let count = 0;

  for (let i = 0; i < arr.length; i++) {
    if (arr[i] !== null && typeof arr[i] === 'object') {
      count++;
    }
  }
  return count;
}

console.log(countTheObjects([5, null, {}, "", null, {}, ""]));

Using the function reduce from ES6:

function countTheObjects(arr) {
  return arr.reduce((count, obj) => count + (obj !== null && typeof obj === 'object'), 0);
}

console.log(countTheObjects([null, {}, 5, "", null, {}, ""]));

Answer 4

You could also do something like this

var input = [
  [1, 2, 3], {
    key: 'some value'
  },
  null, null, 5, 6, null, {}
];

console.log(input.reduce((prev, current) => {
  return current !== null ? prev + 1 : prev
}, 0));

Answer 5

Here's a simple implementation:

let dataArray = [1, {}, [], null, null, 'foo', 3, 4, 5, {}, {}, {}, 'foo']
let countNotNulls = arr => arr.filter( el => el !== null );
console.log(countNotNulls(dataArray).length);

Answer 6

A reliable approach for answering the OP's question boils down to ... just find or implement the correct/matching type detection method. Then, make use of this method as callback function of the filter method that filters the provided array of different/mixed types. Read the length property of the filtered result.

A generic implementation of an isObject check might look like this ...

function isObject(type) {
  return (!!type && (typeof type === 'object'));
};

... but it will let pass any value/type that neither is null nor undefined nor of any other primitive type. Thus it will also let pass other objects like instances of Array, RegExp, Date etc.

The OP wants to test for direct instances of Object. A solution then might look like the following provided ...

function isObjectObject(type) {
  return (/^\[object\s+Object\]$/).test(Object.prototype.toString.call(type));
}

function getObjectCount(list) {
  return Array.from(list).filter(isObjectObject).length;
}

console.log("(getObjectCount([]) === 0) ? ", (getObjectCount([]) === 0));
console.log("(getObjectCount([1, 3, 4, 5]) === 0) ? ", (getObjectCount([1, 3, 4, 5]) === 0));
console.log("(getObjectCount([1, 3, 4, 5, 'foo']) === 0) ? ", (getObjectCount([1, 3, 4, 5, 'foo']) === 0));
console.log("(getObjectCount([1, 3, 4, 5, {}, {}, {}, 'foo']) === 3) ? ", (getObjectCount([1, 3, 4, 5, {}, {}, {}, 'foo']) === 3));
console.log("(getObjectCount([1, [], 3, 4, 5, {}, {}, {}, 'foo']) === 3) ? ", (getObjectCount([1, [], 3, 4, 5, {}, {}, {}, 'foo']) === 3));
console.log("(getObjectCount([1, [], null, 3, 4, 5, {}, {}, {}, 'foo']) === 3) ? ", (getObjectCount([1, [], null, 3, 4, 5, {}, {}, {}, 'foo']) === 3));
console.log("(getObjectCount([1, {}, [], null, null, 'foo', 3, 4, 5, {}, {}, {}, 'foo']) === 4) ? ", (getObjectCount([1, {}, [], null, null, 'foo', 3, 4, 5, {}, {}, {}, 'foo']) === 4));

.as-console-wrapper { max-height: 100%!important; top: 0; }

Answer 7

You are doing unnecessary decrement. You should just move null check to the first if. typeof [] is also 'object'

function countTheObjects (arr) {
let count = 0;

  for (let i = 0; i < arr.length; i++) {
     if (typeof arr[i] === 'object' && arr[i] !== null && !Array.isArray(arr[i]) ) {
       count++;
     }
   }
 return count;
}