The spread operator is kinda cool.

this.results = [ ...this.results, ...data.results];

The spread operator allows you to easily place an expanded version of an array into another array.

You can read about spread operator here.

Are you looking for something like this? You'll need to add types, but you can merge the features arrays from all entries in the data array using vanilla JS methods.

1. Create the output object and specify its type.
2. Use Array#filter to select the entries in data with the matching type.
3. Use Array#flatMap to select the features array from each of the entries above and project their contents into a single array.

const data = [
  { type: 'FeatureCollection', features: [1, 2, 3] },
  { type: 'FeatureCollection', features: [4, 5, 6] }
];

const output = { 
  type: 'FeatureCollection',
  features: data
    .filter(obj => obj.type === 'FeatureCollection')
    .flatMap(obj => obj.features) 
};
  
console.dir(output);

If your environment supports Object.assign, then you can do the same in a succinct way like this

const arrObj = [{a: 1, b: 2}, {c: 3, d: 4}, {e: 5, f: 6}];

console.log(arrObj.reduce(function(result, current) {
  return Object.assign(result, current);
}, {}));

// If you prefer arrow functions, you can make it a one-liner ;-)
console.log(arrObj.reduce(((r, c) => Object.assign(r, c)), {}));

// Thanks Spen from the comments. You can use the spread operator with assign
console.log(Object.assign({}, ...arrObj));

ES5 solution:

You can use Array.prototype.reduce like this

var resultObject = arrObj.reduce(function(result, currentObject) {
    for(var key in currentObject) {
        if (currentObject.hasOwnProperty(key)) {
            result[key] = currentObject[key];
        }
    }
    return result;
}, {});

console.log(resultObject);
# { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 }

This solution, simply gathers all the keys and their values in every object in the result, which is finally returned to us as the result.

This check

if (currentObject.hasOwnProperty(key)) {

is necessary to make sure that we are not including all the inherited enumerable properties in the result.