Update reading progress of Day 14

stevencch99 · stevencch99 · commit 2ce08f9fc933 · 2020-08-10T21:05:41.000+08:00
diff --git a/team/Steven/Day14 - JavaScript Reference VS Copying/README.md b/team/Steven/Day14 - JavaScript Reference VS Copying/README.md
@@ -0,0 +1,42 @@
+# Target - Day 14
+Introducing the reference of an object and ways to copy an Array.
+
+## Key points
+- About reference:
+  ```js
+  a1 = [1, 2, 3];
+  a2 = a1.slice();
+  a3 = a1;
+  a4 = [].concat(a1);
+
+  a1[0] = 2;
+
+  console.log(a1); // [2, 2, 3]
+  console.log(a2); // [1, 2, 3]
+
+  // been changed as well
+  console.log(a3); // [2, 2, 3]
+  console.log(a4); // [1, 2, 3]
+  ```
+
+- An object can have property which reference to a function.
+  ```js
+  var arr = ['a', 'b', 'c'];
+
+  arr.test = function() { return 'Hi'; };
+  arr.test(); // 'Hi'
+
+  typeof(arr); // 'object'
+  ```
+
+- Create a 
+
+
+## Additional Information
+- To compare two arrays in JavaScript
+  ```js
+  a1 = [1, 2, 3];
+  a2 = [1, 2, 3];
+
+  JSON.stringify(a1) === JSON.stringify(a2); // true
+  ```
diff --git a/team/Steven/Day14 - JavaScript Reference VS Copying/index-Steven.html b/team/Steven/Day14 - JavaScript Reference VS Copying/index-Steven.html
@@ -0,0 +1,96 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>JS Reference VS Copy</title>
+</head>
+<body>
+
+  <script>
+    // start with strings, numbers and booleans
+    let age = 100;
+    let age2 = age;
+    console.log(age, age2); // 100 100
+    age = 200;
+    console.log(age, age2); // 200 100
+
+    // Let's say we have an array
+    const players = ['Wes', 'Sarah', 'Ryan', 'Poppy'];
+
+    // and we want to make a copy of it.
+    const team = players; // team is just a reference to the players array
+
+    console.log(players, team);
+    // You might think we can just do something like this:
+    team[3] = 'Lux'; // so this will update the original array: players
+
+    // however what happens when we update that array?
+
+    // now here is the problem!
+
+    // oh no - we have edited the original array too!
+
+    // Why? It's because that is an array reference, not an array copy. They both point to the same array!
+
+    // So, how do we fix this? We take a copy instead!
+    const team2 = players.slice();
+
+    // one way
+
+    // or create a new array and concat the old one in
+    const team3 = [].concat(players);
+
+    // or use the new ES6 Spread
+    const team4 = [...players];
+    team4[3] = 'heeeee haaa';
+    console.log(team4);
+
+    // another good way to copy an array
+    const team5 = Array.from(players);
+    // now when we update it, the original one isn't changed
+
+    // The same thing goes for objects, let's say we have a person object
+
+    // with Objects
+    const person = {
+      name: 'Wes Bos',
+      age: 80
+    };
+
+    // and think we make a copy:
+    const captain = person;
+    captain.number = 99;
+
+    // how do we take a copy instead?
+    const cap2 = Object.assign({}, person, { number: 99, age: 12 });
+    // we take a blank object {}, overwrite the property with person, then use the thrid argument to fold in our own ones.
+    console.log(cap2);
+
+    // We will hopefully soon see the object ...spread
+    // const cap3 = {...person};
+    // use an object spread, that works exactly the same way as we spread into an array.
+    
+
+    // Things to note - this is only 1 level deep - both for Arrays and Objects. lodash has a cloneDeep method, but you should think twice before using it.
+    const sch = {
+      name: 'Steve',
+      age: 100,
+      social: {
+        twitter: '@steve',
+        facebook: 'steve.chang'
+      }
+    }
+
+    console.clear();
+    console.log(sch)
+
+    const dev = Object.assign({}, sch)
+
+    // not 
+    dev.social.twitter = 'color';
+
+    const dev2 = JSON.parse(JSON.stringify(sch));
+  </script>
+
+</body>
+</html>
