ReanyAlex · ReanyAlex · Apr 26, 2017 · Apr 26, 2017 · Apr 26, 2017
diff --git a/bike-shop/src/stage2-constructors.js b/bike-shop/src/stage2-constructors.js
@@ -1,5 +1,4 @@
 function Bike(name, price) {
-  alert(new.target);
   this.name = name
   this.price = price
   this.rings = [3, 7]

diff --git a/bike-shop/src/stage3-methods.js b/bike-shop/src/stage3-methods.js
@@ -1,15 +1,66 @@
 function Bike() {
-  // your code here
+
+  this.rings = [3, 7]
+  this.brakes = {
+    back : true,
+    front : true
+  },
+  this.tires = [new Tire, new Tire],
+  this.frame = new Frame,
+
+  this._isMoving = false
 }
 
 function Frame() {
   // your code here
 }
 
 function Tire() {
-  // your code here
+    this._isFlat = false
 }
 
+
+
+
+Tire.prototype.isFlat = function () {
+  return this._isFlat
+}
+
+Tire.prototype.puncture = function () {
+  this._isFlat = true
+  //this.tires[0]._isFlat = true
+}
+
+
+Tire.prototype.repair = function () {
+  this._isFlat = false;
+}
+
+Bike.prototype.isMoving = function () {
+  return this._isMoving
+}
+
+Bike.prototype.pedal = function () {
+  if (this.tires[0]._isFlat === true) {
+      throw "Can't pedal with a flat tire"
+  }else {
+    this._isMoving = true
+  }
+}
+
+Bike.prototype.brake = function () {
+  this._isMoving = false
+}
+
+Bike.prototype.gearSpeeds = function () {
+  return  this.rings[0] * this.rings[1]
+}
+
+
+
+const myTire = new Tire()
+const myBike = new Bike()
+
 module.exports = {
   Bike: Bike,
   Frame: Frame,

diff --git a/index.html b/index.html
@@ -5,6 +5,6 @@
     <title></title>
   </head>
   <body>
-    <script src="bike-shop/src/stage2-constructors.js" charset="UTF-8"></script>
+    <script src="bike-shop/src/stage3-methods.js" charset="UTF-8"></script>
   </body>
 </html>
diff --git a/jsinfo/createACalc.js b/jsinfo/createACalc.js
@@ -2,6 +2,7 @@
 
 let calculator = {
    read() {
+  // get values
       this.value1 = parseFloat(prompt("what is the first value"));
       this.value2 = parseFloat(prompt("what is the second value"));
   },

diff --git a/jsinfo/createNewCalc.js b/jsinfo/createNewCalc.js
@@ -5,6 +5,7 @@ read() sum() mul() */
 function Calculator() {
 
   this.read = function () {
+    // get values
     this.value1 = parseFloat(prompt("what is the first value"));
     this.value2 = parseFloat(prompt("what is the second value"));
   };

diff --git a/jsinfo/errorInInheritance.js b/jsinfo/errorInInheritance.js
@@ -0,0 +1,27 @@
+/*
+Find an error in the prototypal inheritance below.
+What’s wrong? What are consequences going to be?
+*/
+
+function Animal(name) {
+  this.name = name;
+}
+
+Animal.prototype.walk = function() {
+  alert(this.name + ' walks');
+};
+
+function Rabbit(name) {
+  this.name = name;
+}
+
+//Error it will overwrite all of Rabbit's prototype to Animal's
+Rabbit.prototype = Animal.prototype;
+
+//This will overwrite the previous walk prototype and animals will now bounce and not walk
+Rabbit.prototype.walk = function() {
+  alert(this.name + " bounces!");
+};
+
+let rabbit = new Rabbit;
+let animal = new Animal("skunk");
diff --git a/jsinfo/extendableCalculator.js b/jsinfo/extendableCalculator.js
@@ -1,6 +1,7 @@
 //Create a calculator that can take a string and return the value
 function Calculator() {
 
+//holds new method funtions
   let methods = {
     "+" : function(value1, value2){
       return parseFloat(value1) + parseFloat(value2)
@@ -16,6 +17,7 @@ function Calculator() {
     var value2 = strSplit[2];
     var operator = strSplit[1];
 
+//return the value of the string to be operated on
     return methods[operator](value1, value2)
   };
 

diff --git a/jsinfo/rewritePrototype.js b/jsinfo/rewritePrototype.js
@@ -0,0 +1,79 @@
+//The Clock class is written in functional style. Rewrite it using prototypes.
+
+/*rewrite this
+function Clock({ template }) {
+
+  let timer;
+
+  function render() {
+    let date = new Date();
+
+    let hours = date.getHours();
+    if (hours < 10) hours = '0' + hours;
+
+    let mins = date.getMinutes();
+    if (mins < 10) min = '0' + mins;
+
+    let secs = date.getSeconds();
+    if (secs < 10) secs = '0' + secs;
+
+    let output = template
+      .replace('h', hours)
+      .replace('m', mins)
+      .replace('s', secs);
+
+    console.log(output);
+  }
+
+  this.stop = function() {
+    clearInterval(timer);
+  };
+
+  this.start = function() {
+    render();
+    timer = setInterval(render, 1000);
+  };
+
+}
+
+let clock = new Clock({template: 'h:m:s'});
+   clock.start();
+   */
+
+function Clock({ template }) {
+  this.template = template;
+}
+
+Clock.prototype.render = function(){
+  let date = new Date();
+
+  let hours = date.getHours();
+  if (hours < 10) hours = '0' + hours;
+
+  let mins = date.getMinutes();
+  if (mins < 10) min = '0' + mins;
+
+  let secs = date.getSeconds();
+  if (secs < 10) secs = '0' + secs;
+
+  let output = this.template
+    .replace('h', hours)
+    .replace('m', mins)
+    .replace('s', secs);
+
+  console.log(output);
+}
+
+Clock.prototype.stop = function() {
+  clearInterval(this.timer);
+};
+
+Clock.prototype.start = function() {
+  this.render();
+  this.timer = setInterval(() =>this.render(), 1000);
+};
+
+
+
+let clock = new Clock({template: 'h:m:s'});
+  clock.start();
diff --git a/jsinfo/rewriteToClass.js b/jsinfo/rewriteToClass.js
@@ -0,0 +1,81 @@
+//Rewrite the Clock class from prototypes to the modern “class” syntax.
+
+/*rewrite this
+function Clock({ template }) {
+  this._template = template;
+}
+
+Clock.prototype._render = function() {
+  let date = new Date();
+
+  let hours = date.getHours();
+  if (hours < 10) hours = '0' + hours;
+
+  let mins = date.getMinutes();
+  if (mins < 10) min = '0' + mins;
+
+  let secs = date.getSeconds();
+  if (secs < 10) secs = '0' + secs;
+
+  let output = this._template
+    .replace('h', hours)
+    .replace('m', mins)
+    .replace('s', secs);
+
+  console.log(output);
+};
+
+Clock.prototype.stop = function() {
+  clearInterval(this._timer);
+};
+
+Clock.prototype.start = function() {
+  this._render();
+  this._timer = setInterval(() => this._render(), 1000);
+};
+
+let clock = new Clock({template: 'h:m:s'});
+    clock.start();
+*/
+
+class Clock {
+  // ({ ... }) allows the item to be passed in as a object literal
+  constructor({template}){
+    console.log(typeof({template}));
+  this._template = template;
+  }
+// prototype not allowed in classes. bound to the class function
+  _render() {
+    let date = new Date();
+
+    let hours = date.getHours()
+    if (hours < 10) hours = '0' + hours;
+
+    let mins = date.getMinutes();
+    if (mins < 10) min = '0' + mins;
+
+    let secs = date.getSeconds();
+    if (secs < 10) secs = '0' + secs;
+
+    let output = this._template
+      .replace('h', hours)
+      .replace('m', mins)
+      .replace('s', secs);
+
+    console.log(output);
+  }
+
+//clock.stop() will stop the clock
+  stop() {
+    clearInterval(this._timer);
+  };
+
+//clock.start() would then restart the clock
+  start() {
+    this._render();
+    this._timer = setInterval(() => this._render(), 1000);
+  }
+}
+
+let clock = new Clock({template: 'h:m:s'});
+    clock.start();
diff --git a/jsinfo/searthingAlgo.js → jsinfo/searchingAlgo.js b/jsinfo/searthingAlgo.js → jsinfo/searchingAlgo.js
@@ -9,14 +9,23 @@ let head = {
 };
 
 let table = {
-  pen: 3
+  pen: 3,
+  __proto__ : head
 };
 
 let bed = {
   sheet: 1,
-  pillow: 2
+  pillow: 2,
+  __proto__ : table
 };
 
 let pockets = {
-  money: 2000
+  money: 2000,
+  __proto__ : bed
 };
+
+ /*is it faster to get glasses as pocket.glasses
+ or head.glasses? Benchmark if needed.*/
+
+//It seems that pocket.glasses and head.glasses
+//take about the same amout of time
diff --git a/jsinfo/twoHamsters.js b/jsinfo/twoHamsters.js
@@ -0,0 +1,30 @@
+/*We have two hamsters: speedy and lazy inheriting from the general hamster object.
+When we feed one of them, the other one is also full. Why? How to fix it?
+*/
+
+ let hamster = {
+  stomach: [],
+
+  eat(food) {
+    //this adds apple to the hamster constructor function
+    //this.stomach.push(food)
+
+    //This adds apple to the stomach of the hamster object that called the method
+    this.stomach = [food];
+  }
+};
+
+let speedy = {
+  __proto__: hamster
+};
+
+let lazy = {
+  __proto__: hamster
+};
+
+// This one found the food
+speedy.eat("apple");
+alert( speedy.stomach ); // apple
+
+// This one also has it, why? fix please.
+alert( lazy.stomach ); // apple