Refactored some code, cleaned up the reduce and others

Egrodo · Egrodo · commit 7a9e01fb5838 · 2017-07-16T20:59:28.000-06:00
diff --git a/src/arrays.js b/src/arrays.js
@@ -16,24 +16,20 @@ const reduce = (elements, cb, memo) => {
   // Elements will be passed one by one into `cb`.
   // `memo` is the starting value.  If `memo` is undefined then make `elements[0]` the initial value.
 
-  // TODO come back to later
-  if (memo) memo = elements.shift();
+  if (!memo) memo = elements.shift();
   elements.forEach((value) => {
-    return cb(memo + value);
+    memo = cb(memo, value); // Running total.
   });
+  return memo;
 };
 
 const find = (elements, cb) => {
   // Look through each value in `elements` and pass each element to `cb`.
   // If `cb` returns `true` then return that element.
   // Return `undefined` if no elements pass the truth test.
-
-  // TODO come back to later.
-  elements.forEach((value, i) => {
-    if (cb(value)) {
-      return value;
-    }
-  });
+  for (let i = 0; i < elements.length; i++) {
+    if (cb(elements[i])) return elements[i];
+  }
   return 'undefined';
 };
 
@@ -52,9 +48,6 @@ const filter = (elements, cb) => {
 const flatten = (elements) => {
   // Flattens a nested array (the nesting can be to any depth).
   // Example: flatten([1, [2], [3, [[4]]]]); => [1, 2, 3, 4];
-
-  // For each value in array,
-  // If value is an array, recurse into the value array.
   const arr = [];
   elements.forEach((value) => {
     // First make base case.
diff --git a/src/class.js b/src/class.js
@@ -10,12 +10,13 @@ class User {
     this.email = options.email;
     this.password = options.password;
   }
-  comparePasswords(pwStr) {
-    if (pwStr === this.password) return true;
-    return false;
-  }
 }
 
+User.prototype.comparePasswords = function (str) {
+  if (str === this.password) return true;
+  return false;
+};
+
 /* eslint-disable no-undef */ // Remove this comment once you write your classes.
 
 
@@ -30,19 +31,19 @@ class User {
 class Animal {
   constructor(options) {
     this.age = options.age;
-  }
-  growOlder() {
-    return this.age += 1;
+    this.growOlder = function () {
+      return this.age += 1;
+    };
   }
 }
 
 class Cat extends Animal {
   constructor(options) {
     super(options);
     this.name = options.name;
-  }
-  meow() {
-    return `${this.name} meowed!`;
+    this.meow = function () {
+      return `${this.name} meowed!`;
+    };
   }
 }
 
diff --git a/src/closure.js b/src/closure.js
@@ -6,7 +6,7 @@ const counter = () => {
   // newCounter(); // 1
   // newCounter(); // 2
   let count = 0;
-  return () => {
+  return function () {
     return count += 1;
   };
 };
@@ -16,21 +16,23 @@ const counterFactory = () => {
   // `increment` should increment a counter variable in closure scope and return it.
   // `decrement` should decrement the counter variable and return it.
   let count = 0;
-  return { // Return an object that contains two methods
-    increment: () => (count += 1),
-    decrement: () => (count -= 1)
+  const obj = {};
+  obj.increment = () => {
+    return count += 1;
+  };
+  obj.decrement = () => {
+    return count -= 1;
   };
+  return obj;
 };
 
 const limitFunctionCallCount = (cb, n) => {
   // Should return a function that invokes `cb`.
   // The returned function should only allow `cb` to be invoked `n` times.
-  let count = 0;
-  return (...args) => { // Return a function, accept all parameters as one 'args' array.
-    if (count !== n) {
-      count++;
-      return cb(...args); // In the cb parameters, expand the 'args' spread operator again. and pass them to returned cb.
-    }
+  let callCount = 0;
+  return (...args) => {
+    callCount++;
+    if (n >= callCount) return cb(...args);
     return null;
   };
 };
@@ -42,16 +44,9 @@ const cacheFunction = (cb) => {
   // If the returned function is invoked with arguments that it has already seen
   // then it should return the cached result and not invoke `cb` again.
   // `cb` should only ever be invoked once for a given set of arguments.
-  // const cache = {};
-  // return function (arg) {
-  //   if (Object.keys(cache).includes(arg)) return cache[arg];
-  //   cache[arg] = cb(arg);
-  //   return cache[arg];
-  // };
-
-  const cache = {}; // A cache object should be kept in closure scope to keep track of all arguments that have been used to invoke the function.
+  const cache = {};
   return (input) => {
-    if (Object.prototype.hasOwnProperty.call(cache, input)) return cache[input];
+    if (Object.prototype.hasOwnProperty.apply(cache, [input])) return cache[input];
     cache[input] = cb(input);
     return cache[input];
   };
diff --git a/src/recursion.js b/src/recursion.js
@@ -3,16 +3,35 @@
 const nFibonacci = (n) => {
   // fibonacci sequence: 1 2 3 5 8 13 ...
   // return the nth number in the sequence
+  if (n <= 1) return 1;
+  return nFibonacci(n - 2) + nFibonacci(n - 1);
 };
 
 const nFactorial = (n) => {
   // factorial example: !5 = 5 * 4 * 3 * 2 * 1
   // return the factorial of `n`
+  if (n <= 1) return 1;
+  return n * nFactorial(n - 1);
 };
 
 const checkMatchingLeaves = (obj) => {
-  // return true if every property on `obj` is the same
-  // otherwise return false
+  // return true if every property on `obj` is the same.
+  // otherwise return false.
+  const obs = [obj]; // Set 'obs' to equal a 2d array of the object.
+  let check;
+  let flag = true;
+  const helper = (o) => {
+    const vals = Object.values(o);
+    for (let i = 0; i < vals.length; i++) { // Loop through values in object to check if they're all the same.
+      if (typeof vals[i] !== 'object' && !check) check = vals[i]; // Set check equal to the first value in the object.
+      if (typeof vals[i] !== 'object' && check !== vals[i]) return flag = false; // If the current value is not an object AND check is not the same as the current value, return 'flag' as false.
+      if (typeof vals[i] === 'object') obs.push(vals[i]); // If the current value IS an object, add the current value to the 'obs' object.
+    }
+  };
+  for (let i = 0; i < obs.length; i++) { // Loop through the 'obs' array.
+    helper(obs[i]); // For each value in the 'obs' array pass it to the helper function.
+  }
+  return flag; // Return the state of flag, which will only be false if specifically set false.
 };
 
 /* eslint-enable no-unused-vars */
diff --git a/src/this.js b/src/this.js
@@ -5,6 +5,12 @@
 class User {
   constructor(options) {
     // set a username and password property on the user object that is created
+    this.username = options.username;
+    this.password = options.password;
+    this.checkPassword = function (str) {
+      if (str === this.password) return true;
+      return false;
+    };
   }
   // create a method on the User class called `checkPassword`
   // this method should take in a string and compare it to the object's password property
@@ -19,13 +25,19 @@ const checkPassword = function comparePasswords(passwordToCompare) {
   // use `this` to access the object's `password` property.
   // do not modify this function's parameters
   // note that we use the `function` keyword and not `=>`
+  if (this.password === passwordToCompare) return true;
+  return false;
 };
 
 // invoke `checkPassword` on `me` by explicitly setting the `this` context
 // use .call, .apply, and .bind
 
 // .call
-
+checkPassword.call(me, 'correcthorsebatterystaple');
+checkPassword.call(me, 'incorrecthorsebatterystaple');
 // .apply
-
+checkPassword.apply(me, ['correcthorsebatterystaple']);
+checkPassword.apply(me, ['incorrecthorsebatterystaple']);
 // .bind
+checkPassword.bind(me, 'correcthorsebatterystaple')();
+checkPassword.bind(me, 'incorrecthorsebatterystaple')();
