Mutability

var someGreeting = "hello";
var otherGreeting = someGreeting;

console.log(someGreeting);              // Logs: hello
console.log(otherGreeting);             // Logs: hello

// we have a variable, someGreeting, that contains the string value “hello” (a primitive type). We also have a second variable, otherGreeting, pointing to the same string value. If we mutated the string value being pointed to by these two variables, then we would expect both of the variables to reflect that change. So, we try to do this by calling the ostensibly transformative concat method on someGreeting

someGreeting.concat("!!!");   // return value: "hello!!!"

//  however, when we then log the values of both someGreeting and otherGreeting, neither has changed. This is because strings are primitive and cannot be mutated. The concat method returned a new string but we didn’t do anything with it.
console.log(someGreeting);              // Logs: hello
console.log(otherGreeting);             // Logs: hello


// Similarly, we can see that individual characters in a string can be accessed by index (as with an array); however, when we attempt to reassign one of those characters it has no result on the overall string, because again, strings are immutable.

console.log(someGreeting[1]);           // Logs: e
someGreeting[1] = "a";
console.log(someGreeting[1]);           // Logs: e

// we call concat() once more, this time using its return value to be reassigned to the someGreeting variable, and we do indeed see our expected change. But because this was reassignment, rather than mutation, otherGreeting is still pointing to the original value.
someGreeting = someGreeting.concat("!!!");  // reassignment

console.log(someGreeting);              // Logs: hello!!!
console.log(otherGreeting);             // Logs: hello

var favoritePlanets = ["Mars", "Saturn", "Earth"];
console.log(favoritePlanets);     // Logs: [ 'Mars', 'Saturn', 'Earth' ]

// we call the Array.prototype.sort method, which sorts an array in place (meaning that it mutates the original array), and as expected, our array changes.
console.log(favoritePlanets);     // Logs: [ 'Earth', 'Mars', 'Saturn' ]

// We push a new string to the array, and once more, we see that the array is mutated
favoritePlanets.push("Jupiter");  // Logs:
console.log(favoritePlanets);     // Logs: [ 'Earth', 'Mars', 'Saturn', 'Jupiter' ]


// Next, I attempt to mutate the first element in the favoritePlanets array ( so could have naively expected the first element should have been 'Earth2' ) , but as we learned earlier this doesn’t actually work and so we get no change — thus demonstrating that compound types are mutable but the primitive types contained therein are not.
favoritePlanets[0].concat("2");
console.log(favoritePlanets);     // Logs: [ 'Earth', 'Mars', 'Saturn', 'Jupiter' ]


// However, primitive types inside a compound type can be reassigned. We can see this below, when we define an object called lifeDiscovered and then reassign one of its elements. The lifeDiscovered object has been mutated by virtue of one of its parts being reassigned.

var lifeDiscovered = {
  "Earth": true,
  "Mars": false,
  "Titan": false,
};

console.log(lifeDiscovered);
  // Logs: { Earth: true, Mars: false, Titan: false }

lifeDiscovered["Mars"] = true;
console.log(lifeDiscovered);