Objects don't have a .length property.

A simple solution if you know you don't have to worry about hasOwnProperty checks, would be to do this:

Object.keys(data).length;

If you have to support IE 8 or lower, you'll have to use a loop, instead:

var length= 0;
for(var key in data) {
    if(data.hasOwnProperty(key)){
        length++;
    }
}

You have spelling mistake

 var test = cars.length;

You can create an array using array syntax:

    array = ["first item", {second:'item'}, 3];
    array.def = {something:"else"};
    alert(array.length);

And here's how you create a multidimensional array using an array of arrays:

    array = [
        [1,2,3],
        [4,5,6],
        [7,8,9]
    ];

    alert(array[0][2]); // alerts "3"

Thanks to Pietro, I found the solutions via Google after knowing about Object.keys().

Object.keys(roles).forEach(function(key) {
    console.log(key + ': ' + roles[key]);
});

For the guys who down voted, it's a new thing I learnt today about Object.keys(). Thanks for your encouragement by down voting. :)

Note: Array indexes are nothing but properties of Array objects.

Quoting MDN's Relationship between length and numerical properties section,

When setting a property on a JavaScript array when the property is a valid array index and that index is outside the current bounds of the array, the engine will update the array's length property accordingly.

Quoting ECMA Script 5 Specification of Array Objects,

whenever a property is added whose name is an array index, the length property is changed, if necessary, to be one more than the numeric value of that array index; and whenever the length property is changed, every property whose name is an array index whose value is not smaller than the new length is automatically deleted

So, when you set a value at index 5, JavaScript engine adjusts the length of the Array to 6.

Quoting ECMA Script 5 Specification of Array Objects,

A property name P (in the form of a String value) is an array index if and only if ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal to 2³²−1.

So, in your case 2 and 4 are valid indexes but only 2 is defined in the array. You can confirm that like this

arr.hasOwnProperty(2)

The other indexes are not defined in the array yet. So, your array object is called a sparse array object.

So why arr[2] is counted in for..in loop and not arr[4] is not counted?

The for..in enumerates all the valid enumerable properties of the object. In your case, since only 2 is a valid property in the array, it will be counted.

But, when you print arr[4], it prints undefined, because JavaScript will return undefined, if you try to access a property which is not defined in an object. For example,

console.log({}['name']);
// undefined

Similarly, since 4 is not yet defined in the arr, undefined is returned.

While we are on this subject, you might want to read these answers as well,

• Why doesn't the length of the array change when I add a new property?

• JavaScript 'in' operator for undefined elements in Arrays

Arrays are zero-based indexing. Which means The first element of the array is indexed by subscript of 0 and last element will be length - 1

const arr = [2 , 3, 6, 8];
const end = arr[ arr.length - 1 ];
console.log(end);

That's because coordinates is Object not Array, use for..in

var coordinates = {
     "a": [
         [1, 2],
         [8, 9],
         [3, 5],
         [6, 1]
     ],

     "b": [
         [5, 8],
         [2, 4],
         [6, 8],
         [1, 9]
     ]
 };

for (var i in coordinates) {
  console.log(coordinates[i]) 
}

or Object.keys

var coordinates = {
  "a": [
    [1, 2],
    [8, 9],
    [3, 5],
    [6, 1]
  ],

  "b": [
    [5, 8],
    [2, 4],
    [6, 8],
    [1, 9]
  ]
};

var keys = Object.keys(coordinates);

for (var i = 0, len = keys.length; i < len; i++) {
  console.log(coordinates[keys[i]]);
}

Because the last element in the array is undefined.

The array has 3 elements 1, 2 and undefined where undefined has the index 2 and the array has a length of 3.

Thus when array[array.length - 1] is returned it is undefined

The reason is that you're not logging superArray in your fetch promise. If you add the call to console.log() in your last then() call it works. The reason for this is that fetch is executed asynchronously, which means that any additional code that comes after the fetch call is executed long before the fetch has returned anything.

The reason you can see a full log of superArray even when doing it outside the fetch is a special console behaviour.

const URL1 = "https://www.politifact.com/api/statements/truth-o-meter/people/barack-obama/json/?n=50";
const URL2 = "https://www.politifact.com/api/statements/truth-o-meter/people/hillary-clinton/json/?n=210";
const URL3 = "https://www.politifact.com/api/statements/truth-o-meter/people/bernie-s/json/?n=70";
var superArray = [];
fetch("https://cors-anywhere.herokuapp.com/" + URL1)
  .then(results => {
    return results.json();
  })
  .then(data => {
    data = data.filter(function(item) {
      return item.speaker.name_slug == "barack-obama" && item.statement_type.statement_type !== "Flip";
    });
    for (var i = 0; i < 10; i++) {
      superArray.push(data.splice(Math.random() * data.length, 1)[0]);
    }
  })
fetch("https://cors-anywhere.herokuapp.com/" + URL2)
  .then(results => {
    return results.json();
  })
  .then(data => {
    data = data.filter(function(item) {
      return item.speaker.name_slug == "hillary-clinton" && item.statement_type.statement_type !== "Flip";
    });
    for (var i = 0; i < 10; i++) {
      superArray.push(data.splice(Math.random() * data.length, 1)[0]);
    }
  })
fetch("https://cors-anywhere.herokuapp.com/" + URL3)
  .then(results => {
    return results.json();
  })
  .then(data => {
    data = data.filter(function(item) {
      return item.speaker.name_slug == "bernie-s" && item.statement_type.statement_type !== "Flip";
    });
    for (var i = 0; i < 10; i++) {
      superArray.push(data.splice(Math.random() * data.length, 1)[0]);
    }
    console.log(superArray[0]);
  })

lenght = length!!

So there you go!

That's because length gives you the next index available in the array.

DOCS

arrayLength

If the only argument passed to the Array constructor is an integer between 0 and 2^32-1 (inclusive), this returns a new JavaScript array with length set to that number.

ECMA Specifications

Because you don't have inserted any element in the other keys than 21, 90, 13, all the remaining indexes contains undefined. DEMO

To get actual number of elements in the array:

var a = [];
a[21] = {};
a[90] = {};
a[13] = {};

var len = 0;

for (var i = 0; i < a.length; i++) {
  if (a[i] !== undefined) {
    len++;
  }
}
document.write(len);

Shorter version

var a = [];
a[21] = {};
a[90] = {};
a[13] = {};


for (var i = 0, len = 0; i < a.length; i++, a[i] !== undefined && len++);


document.write(len);

DEMO

EDIT

If the array contains large number of elements, looping to get its length is not the best choice.

As you've mentioned in the question, Object.keys(arr).length is the best solution in this case, considering that you don't have any properties added on that array. Otherwise, the length will not be what you might be expecting.(Thanks To @RobG)

you should use the toJSON() function of VanillaSerializer to return the data as json, like the following.

 const imageData = await Image.query().where('product_id', product.id).fetch();
 const images = imageData.toJSON();

then you can loop through the images like you did.

I would wager that one of the payrollDb[i] is undefined. After this line:

for(let i=0; i<payrollDb.length; i++) {

Add a check to log the [i] before your next loop. Then when it errors the location that is causing an issue should show up, and you should be able to code around it. You could also wrap the second for in a conditional to skip it if it's undefined.

  for(let i=0; i<payrollDb.length; i++) {
      if ([i] === undefined) { // check the type equals undefined
          for(let j=0; j<payrollDb[i].length; j++) {

room.clients is undefined which is why you get that error. The reason it's undefined is because room is a string.

A for..in loop iterates over the keys of an object. This means that room === "ijxeczyu", assuming you're passing in your rooms object. To get access to the object, you'll have to access the object at that key.

for (var name in obj) {
  var room = obj[name];
  ...
}

var selected = {};

doesn't build an array but an object, which has no length property.

You can fix your code by replacing it with

var selected = [];

If you want to return an array of numbers, you can change your code to

function stringToIntArray(string) {
    var split = string.split(',');
    var selected = [];
    for (var i = 0; i < split.length; i++) {
        selected.push(parseInt(split[i], 10));
    }
    return selected;
}

Note that I replaced <= with < in your loop.

Note also that for modern browsers, you can use the map function to make it simpler :

function stringToIntArray(string) {
    return string.split(',').map(function(v){ return parseInt(v, 10) });
}

JavaScript doesn't have a .length property for objects. If you want to work it out, you have to manually iterate through the object.

function objLength(obj){
  var i=0;
  for (var x in obj){
    if(obj.hasOwnProperty(x)){
      i++;
    }
  } 
  return i;
}


alert(objLength(JSONObject)); //returns 4

Edit:

Javascript has moved on since this was originally written, IE8 is irrelevant enough that you should feel safe in using Object.keys(JSONObject).length instead. Much cleaner.

As per my comment: you need to pass in array to the sort function again:

if (swapped) {
  return sort(array);
}

That's because categoryData is not an Array - it's an Object. And while some JS objects (arguments, for example) support length property, those created with object literal notation do not.

You can count your object's length by yourself, with this:

function countProps(obj) {
    var count = 0;
    for (var p in obj) {
      obj.hasOwnProperty(p) && count++;
    }
    return count; 
}

This can be done even in a more simple way, if your target environment supports (or has it shimmed) the Object.keys method:

function sizeObj(obj) {
  return Object.keys(obj).length;
}

... and that's exactly how it's done in Underscore.js library method:

_.size = function(obj) {
    if (obj == null) return 0;
    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
};