# Return a Sorted Array Without Changing the Original Array.help

Return a Sorted Array Without Changing the Original Array.help
0

#1

Tell us what’s happening:
`nonMutatingSort(globalArray) should return [2, 3, 5, 6, 9]`
My exercise tell me that and this is wrong.Can you tell me where is my wrong?

``````
var globalArray = [5, 6, 3, 2, 9];
function nonMutatingSort(arr) {
var globalArray = [5,6,3,2,9];
function nonMutationSort(arr) {
return [].concat(arr).sort( (a,b) => a > b );
}

}
nonMutatingSort(globalArray);
``````

User Agent is: `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36`.

#2

You declared globalArray twice in your code

I see this part of the code appearing twice

``````var globalArray = [5,6,3,2,9];
function nonMutationSort(arr) {
``````

#3

I remove that code `var globalArray = [5,6,3,2,9];`
But again that `nonMutatingSort(globalArray) should return [2, 3, 5, 6, 9].` is wrong

#7

var globalArray = [5, 6, 3, 2, 9];
function nonMutatingSort(arr) {
return globalArray.concat(arr).sort( (a,b) => a - b );

}
nonMutatingSort(globalArray);

This is my new code but isn’t right

#9

Where can I write that code you send me.

#10

You need not mutate the global array just create a new array in function and then do all the operations on it and return it.
Just declare the new array and then push items of existing globalarray in it using concat.
Try solving now.

#12

``````var globalArray = [5, 6, 3, 2, 9];

function nonMutatingSort(arr) {

}

// Use this to call your function with the parameter
// that you've already defined as globalArray
nonMutatingSort(globalArray);
``````

In the actual function, you just have to return and modify `arr` with `sort()`

Your function should `return` the `arr` array with the `sort()` method applied to it.

answer will just be a single line of code.

#13

What I exactly do because I on’t understand.Can you help me more?

#14
``````var globalArray = [5, 6, 3, 2, 9];
function nonMutatingSort(arr) {

_`You must change the code here only.`_

}
nonMutatingSort(globalArray);
``````

#16

This won’t work. `globalArray` is a reference to a global array. Calling sort on it mutates that array - the fact it is being passed into a function makes no difference, it’s still exactly the same array: this is explicitly what the exercise is explaining.

It isn’t the same - globalArray references a specific location in memory, and if you call sort on it, it will sort the referenced `globalArray`. This is why the exercise says to use `concat`

@Klaudia `concat` creates a new array from an array + some value you put in as an argument to the concat function. So if you do

``````> var oldArray = [1,2,3]
> var newArray = [1,2,3].concat(oldArray)
``````

`oldArray` will still be `[1,2,3]`, and `newArray` will be `[1,2,3,1,2,3]`.

Similarly, if you concat an array onto an empty array, it will just create a new array that looks the same as the original one:

``````> var oldArray = [1,2,3]
> var newArray = [].concat(oldArray)

// There are _not_ the same array:
> oldArray
[1,2,3]
> newArray
[1,2,3]
``````

In this case, you are making a copy of `oldArray`

`arr` in the function is just an array that gets passed in, which could be `globalArray` or it could be any other array - dont reference `globalArray` inside the function, that is just something that gets used during the tests.

What you are supposed to be doing is, inside the function, making a copy of `arr` and then returning a sorted version of that copy

#18

@DanCouper

``````var array1 = [1,2,3];
var array2 = [].concat(array1);
array2[0] +=5;
``````

Using `concat()`, will this deep copy the objects in the array1, or will the new array2 still reference the original objects? If you mutate them, will it impact the original array as well?

#19

`concat` creates a new array. See

If you mutate something, that means it is changed, that’s the definition.

#20

I understand `concat` creates a new array. I was wondering if the objects of the new array would be references to the objects in the original array? Or, would they be new separate objects and therefore changes on one object (in the new array or old array) would not change the object in the other array automatically.

Thanks again for any clarification.

#21

No, it’s a new array. Any non mutating methods copy/create. If you have a refence to another object in the array, and you copy that reference, then that’s still a reference to the original object (you’re making a shallow copy), but you are creating a completely new object

#22

So, mutating the shallow copy of the object in the new array would then be reflected in the reference to that same object in the original array?

#23
``````const someArr = [1,2,3];
const anotherArr = someArr.slice();
const andAnother = someArr.concat(anotherArr);
const anotherOne = andAnother.map(x => x + 1);
const yetAnotherOne = [...anotherOne];
``````

So every one of those is a different array, there is no effect on the previous arrays.

``````arrayOfReferences = [someArray, anotherArray, andAnother, anotherOne, yetAnotherOne]
``````

This is a collection of references to other arrays. If I do

``````arrayOfReferences[0].push(4);
``````

This will mutate the original array `someArray`. This isn’t a terribly common thing to do though outside of say game programming, because it gets nightmarishly hard to keep track of what’s happening. Arrays of objects it’s much more common, but it’s still preferable to not do it, or even better just flatten everything to one-dimensional data as much as is possible.