The difference here is best demonstrated in the following example:

var arrayA = [1,2,3,4,5];

function clearUsingLength (ar) {
    ar.length = 0;
}

function clearByOverwriting(ar) {
    ar = [];
}

alert("Original Length: " + arrayA.length);
clearByOverwriting(arrayA);
alert("After Overwriting: " + arrayA.length);
clearUsingLength(arrayA);
alert("After Using Length: " + arrayA.length);

Of which a live demo can be seen here: http://www.jsfiddle.net/8Yn7e/

When you set a variable that points to an existing array to point to a new array, all you are doing is breaking the link the variable has to that original array.

When you use array.length = 0 (and other methods like array.splice(0, array.length) for instance), you are actually emptying the original array.

Because that is not how you add an item since Arrays only accept numeric keys. You do it like this:

errors.push("blah");  /*or*/  errors[0] = "blah";

//Now if you check the length:
errors.length;  //1

Also, if you are using it as an Object, '' isn't a valid name either.

*Correction: Looks like you can use "" (empty string) as a key.

So what actually happens is that when you log your response it actually having length as 0. But after the asynchronous response is returned it has 42 items but length being a property is logged as number. But your response being an object is logged initially with zero items. But when the actual response is received the reference to the response object is updated and you see that the response is having 42 items and length is also 42. The below code is an example for that that to show after the setTimeout is called the logged response is updated in the console.

var getTopSelection = function(callback) {
    var topSelection = [];
    markers=[1,2,3,4,5,6,7,8,9];
    for(var i=0; i < markers.length; i++) {
        if(markers[i].map !== null) {
            var stationID = markers[i].id;
            getTrips(stationID, function(response) {
                topSelection.push({
                    StationID: i,
                    Trips: response
                });
            }, function(error) {
                console.log(error);
            })
        }
    }
    callback(topSelection);
};

function getTrips(station,fun){
setTimeout(function(){
	fun(["trip1","trip2","trip3"]);
},1000)
}
getTopSelection(function(response) {
            console.log(response); //115
            console.log(response.length); //116
})

Try executing this snippet(have modified accordingly to show what actually happens) in a Fiddle here. And observe the output in console as in stackoverflow snippet result it wont be visible. Here is snap of the Console Output

Hope it helps :)

JavaScript arrays does not work like those in for instance PHP which can work as associative arrays. However, due to JavaScript's dynamic nature, and the fact that an Array is a subclass of Object, you can still attach arbitrary properties on to a Array. The length property will however not reflect this (as you have discovered).

If you're using newer browsers/polyfills (like core-js), I recommend going with Map instead (Documentation). Otherwise, use a simple object ({}), and use Object.keys on the object to get the keys.

Example of the later:

var mappings = {};
mappings['foo'] = 'bar';
Object.keys(mappings); // returns ['foo']
mappings[Object.keys(mappings)[0]]; // returns 'bar'

// Loop through all key-value pairs
Object.keys(mappings).forEach(function(key) {
  var value = mappings[key];
  // Do stuff with key and value.
});

>>> is the bitwise "zero-fill right shift" operator.

JavaScript numbers can represent both integers and floating point numbers. Sometimes you only want an integer. Any positive JavaScript Number representing a number less than 2^32 will be rounded down (truncated, as in Math.floor) to the nearest integer. Numbers ≥ 2^32 are turned to 0. Numbers less than 0 will turn into a positive value (thanks to the magic of two's-complement representation).

However, this.length would presumably ALWAYS be an integer less than 2^32…so I can't explain why the code would be doing that. The result should be the same as this.length.

You are doing console.log before getting response in subscribe. Just move console.log inside subscribe.

var objects = [];

this.get().subscribe(
  response => {
    for (var i = 0; i < response.length; i++) {
      objects.push(response[i]);
    }
    console.log(objects.length);
  }
);

array.length is fastest and shorter than array.length > 0. You can see difference of their speeds : http://jsperf.com/test-of-array-length

if(array.length){...} is similar to if(0){...} or if(false){...}