Merge branch 'master' into sync-d6e88647

Author: raikusy

Diff for: 1-js/04-object-basics/02-object-copy/article.md

@@ -1,3 +1,4 @@
+
 # Object references and copying
 
 One of the fundamental differences of objects versus primitives is that objects are stored and copied "by reference", as opposed to primitive values: strings, numbers, booleans, etc -- that are always copied "as a whole value".
@@ -8,6 +9,7 @@ Let's start with a primitive, such as a string.
 
 Here we put a copy of `message` into `phrase`:
 
+
 ```js
 let message = "Hello!";
 let phrase = message;
@@ -25,12 +27,14 @@ Objects are not like that.
 
 Let's look at an example of such variable:
 
+
 ```js
 let user = {
   name: "John"
 };
 ```
 
+
 And here's how it's actually stored in memory:
 
 ![](variable-contains-reference.svg)
@@ -50,6 +54,7 @@ For instance:
 ```js no-beautify
 let user = { name: "John" };
 
+
 let admin = user; // copy the reference
 ```
 
@@ -61,6 +66,7 @@ As you can see, there's still one object, now with two variables that reference
 
 We can use any variable to access the object and modify its contents:
 
+
 ```js run
 let user = { name: 'John' };
 
@@ -96,9 +102,11 @@ And here two independent objects are not equal, even though they look alike (bot
 let a = {};
 let b = {}; // two independent objects
 
+
 alert( a == b ); // false
 ```
 
+
 For comparisons like `obj1 > obj2` or for a comparison against a primitive `obj == 5`, objects are converted to primitives. We'll study how object conversions work very soon, but to tell the truth, such comparisons are needed very rarely, usually they appear as a result of a programming mistake.
 
 ## Cloning and merging, Object.assign
@@ -120,6 +128,7 @@ let user = {
 };
 
 *!*
+
 let clone = {}; // the new empty object
 
 // let's copy all user properties into it
@@ -128,6 +137,7 @@ for (let key in user) {
 }
 */!*
 
+
 // now clone is a fully independent object with the same content
 clone.name = "Pete"; // changed the data in it
 
@@ -142,6 +152,7 @@ The syntax is:
 Object.assign(dest, [src1, src2, src3...])
 ```
 
+
 - The first argument `dest` is a target object.
 - Further arguments `src1, ..., srcN` (can be as many as needed) are source objects.
 - It copies the properties of all source objects `src1, ..., srcN` into the target `dest`. In other words, properties of all arguments starting from the second are copied into the first object.
@@ -174,6 +185,7 @@ alert(user.name); // now user = { name: "Pete" }
 
 We also can use `Object.assign` to replace `for..in` loop for simple cloning:
 
+
 ```js
 let user = {
   name: "John",
@@ -192,6 +204,7 @@ It copies all properties of `user` into the empty object and returns it.
 Until now we assumed that all properties of `user` are primitive. But properties can be references to other objects. What to do with them?
 
 Like this:
+
 ```js run
 let user = {
   name: "John",
@@ -208,6 +221,7 @@ Now it's not enough to copy `clone.sizes = user.sizes`, because the `user.sizes`
 
 Like this:
 
+
 ```js run
 let user = {
   name: "John",