Homework 4

exercises.js

@@ -4,27 +4,44 @@ function multiplyArguments() {
   // use the arguments keyword to multiply all of the arguments together and return the product
   // if no arguments are passed in return 0
   // if one argument is passed in just return it
+  if (arguments.length === 0) {
+    return 0;
+  } else {
+      var holder = 1;
+      for (var i = 0; i < arguments.length; i++) {
+        holder *= arguments[i];
+    }
+    return holder;
+  }
 }
 
+
 function invokeCallback(cb) {
   // invoke cb
+  cb();
 }
 
 function sumArray(numbers, cb) {
   // sum up all of the integers in the numbers array
   // pass the result to cb
   // no return is necessary
+  var summer = numbers.reduce(function (a, b) {
+     return a + b; }, 0);
+  cb(summer);
 }
 
 function forEach(arr, cb) {
   // iterate over arr and pass its values to cb one by one
   // hint: you will be invoking cb multiple times (once for each value in the array)
+  arr.forEach(function(num) { cb(num); });
 }
 
 function map(arr, cb) {
   // create a new array
   // iterate over each value in arr, pass it to cb, then place the value returned from cb into the new arr
   // the new array should be the same length as the array argument
+  return arr.map(function(val) {return cb(val); });
+
 }
 
 function getUserConstructor() {
@@ -34,25 +51,51 @@ function getUserConstructor() {
   // the constructor should have a method 'sayHi' on its prototype that returns the string 'Hello, my name is {{name}}'
   // {{name}} should be the name set on each instance
   // return the constructor
+  function User(options) {
+    this.username = options.username;
+    this.name = options.name;
+    this.email = options.email;
+    this.password = options.password;
+  }
+  User.prototype.sayHi = function() {
+    return 'Hello, my name is ' + this.name;
+  };
+
+  return User;
+
 }
 
 function addPrototypeMethod(Constructor) {
   // add a method to the constructor's prototype
   // the method should be called 'sayHi' and should return the string 'Hello World!'
+  Constructor.prototype.sayHi = function() {
+    return 'Hello World!';
+  };
 }
 
 function addReverseString() {
   // add a method to the string constructor's prototype that returns a reversed copy of the string
   // name this method reverse
   // hint:
   // you will need to use 'this' inside of reverse
+  String.prototype.reverse = function() {
+    var str = this;
+    return str.split('').reverse().join('');
+  };
 }
 
 function nFactorial(n) {
   // return the factorial for n
   // solve this recursively
   // example:
   // the factorial of 3 is 6 (3 * 2 * 1)
+  if (n == 0) {
+    return 1;
+  }
+  else {
+    return n * nFactorial(n - 1);
+  }
+
 }
 
 function cacheFunction(cb) {
@@ -67,6 +110,18 @@ function cacheFunction(cb) {
   // if the function you return is invoked with 5 it would pass 5 to cb(5) and return 25
   // if the function you return is invoked again with 5 it will look on an object in the closure scope
   // and return 25 directly and will not invoke cb again
+  var argsObj = {};
+  var closureFunction = function (argu) {
+
+    if (argu in argsObj) {
+        return argsObj[argu];
+    }
+    else {
+        argsObj[argu] = cb(argu);
+        return argsObj[argu];
+    }
+    };
+  return closureFunction;
 }
 
 

explanations.txt

@@ -0,0 +1,11 @@
+1. A callback function is passed into another function as an argument, and is run from within that receiving function.
+
+2. A closure is a function and its lexical environment. In other words, it is the function and the objects that it references within its scope. A nested function, when instantiated outside its outer function, will create a closure of that function and the objects in its original scope it requires to function.
+
+3. Arguments are the values that are passed into a function's as input. JS allows a function to take more or less arguments than there are parameters, unlike Python, for instance.
+
+4. Recursion is the process in which a function calls itself directly or indirectly.
+
+5. A prototype is the fundamental building block of prototype inheritance. The prototype is the object that the inheriting object's __proto__ property refers to. The inheriting object doesn't actually own any of the properties in the prototype. Instead, the prototype's properties can be referenced on the object as it they were its own. It is the building block of the prototype chain.
+
+6. A constructor function is used with the `new` keyword to produce a specialized (cookie-cutter) object. It can be thought of as a class, even though the details of class functionality in other languages are going to be different.