The concat method on arrays is used to take two arrays and concatenate them into one. It takes as many arrays as you like - so you can concatenate many arrays at once:
Array.concat(value1, value2, value3, ...valueN)
Each item added to the concat method must be of type array. Let's look at a simple example. Below, we combine two arrays:
let myArray = [ 1, 2, 3, 4, 5 ];
let newArray = [ 'n', 'a', 'e', 'k' ]
let mergedArray = myArray.concat(newArray);
console.log(mergedArray); // [ 1, 2, 3, 4, 5, 'n', 'a', 'e', 'k' ]
concat does not remove duplicates - but if you are interested in a data structure which does, you might want to read my guide on Javascript sets.
The concat method creates a shallow copy of the array it's applied to, with the addition of any other arrays added to the end. You can learn more about shallow copies here.
That means that although it seems like a new array is created, it still has a connection with the original array you modified. In fact, every array you mention in concat is a shallow copy of the original. Consider the following example:
let myArray = [ { name: "John" }, 1, 2, 3, 4, 5 ];
let newArray = [ { name: "Jacob" }, 'a', 'e', 'k' ]
let mergedArray = myArray.concat(newArray);
myArray[0].name = "Jingleheimer";
newArray[0].name = "Schmidt";
newArray[1] = 5;
console.log(mergedArray, myArray); // [ { name: "Jingleheimer" }, 1, 2, 3, 4, 5, { name: "JSchmidtacob" }, 'a', 'e', 'k' ]
You might expect that changing name on myArray and newArray does not affect mergedArray - but it does. However, newArray[1] = 5 has no effect on mergedArray.
You can learn the details of why this works like this here, but the basic premise is that the arrays we used in concat maintain the same reference in memory as the original arrays. Updating name updates both the mergedArray and the original arrays since they are all stored in the same place. However, typing newArray[1] tells Javascript to put a completely new value in position [1] of mergedArray.
This is important to remember when you run into weird Javascript array errors.
Concating multiple arrays
We've looked at how you can concatenate two arrays, but concatenating more works in much the same way. You list all your arrays in the concat function like so:
let myArray = [ 1, 2, 3, 4, 5 ];
let newArray = [ 'n', 'a', 'e', 'k' ]
let anotherArray = [ 7, 1, 5, 7 ]
let mergedArray = myArray.concat(newArray, anotherArray);
console.log(mergedArray); // [ 1, 2, 3, 4, 5, 'n', 'a', 'e', 'k', 7, 1, 5, 7 ]
The arrays are merged in the order they are mentioned.
Concatenating nested arrays
Nested arrays are concatenated in the same way. The outer array is removed, meaning that the nested elements become part of the first array:
let myArray = [ [1, [2, 3], 4], 5 ];
let newArray = [ ['n', 'a'], 'e', 'k' ]
let mergedArray = myArray.concat(newArray);
console.log(mergedArray); // [ [1, [2, 3], 4], 57, ['n', 'a'], 'e', 'k' ]
Values in concatenated arrays
If you do pass a simple value to concat, it will treat it as an array element. That means if you passed in 'value' rather than ['value'], it would coerce it to ['value'] anyway:
let myArray = [ 1, 2, 3, 4, 5 ];
let mergedArray = myArray.concat(1, 2, 3);
console.log(mergedArray); // [ 1, 2, 3, 4, 5, 1, 2, 3 ]
Top comments (0)