From 6a0385c2d4d6c844643f445ecb026e2d4a339531 Mon Sep 17 00:00:00 2001 From: Alex Reany Date: Mon, 24 Apr 2017 12:57:32 -0700 Subject: [PATCH 1/6] stage 1 complete --- index.html | 10 ++++++++ jsinfo/chaining.js | 46 ++++++++++++++++++++++++++++++++++ jsinfo/createACalc.js | 20 +++++++++++++++ jsinfo/helloObject.js | 15 +++++++++++ jsinfo/multiplyNumericByTwo.js | 23 +++++++++++++++++ 5 files changed, 114 insertions(+) create mode 100644 index.html create mode 100644 jsinfo/chaining.js create mode 100644 jsinfo/createACalc.js create mode 100644 jsinfo/helloObject.js create mode 100644 jsinfo/multiplyNumericByTwo.js diff --git a/index.html b/index.html new file mode 100644 index 0000000..449f707 --- /dev/null +++ b/index.html @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/jsinfo/chaining.js b/jsinfo/chaining.js new file mode 100644 index 0000000..e7247ad --- /dev/null +++ b/jsinfo/chaining.js @@ -0,0 +1,46 @@ +// There’s a ladder object that allows to go up and down +/* +let ladder = { + step: 0, + up() { + this.step++; + return this; + }, + down() { + this.step--; + return this; + + }, + showStep: function() { // shows the current step + alert( this.step ); + return this; + + } +}; + +we need to make several calls in sequence, can do it like this: +ladder.up(); +ladder.up(); +ladder.down(); +ladder.showStep(); // 1 +*/ + +//rewrite the code to make it chainable +let ladder = { + step: 0, + up() { + this.step++; + return this; + }, + down() { + this.step--; + return this; + + }, + // shows the current step + showStep: function() { + alert( this.step ); + return this; + } +}; +ladder.up().up().down().showStep(); // 1 diff --git a/jsinfo/createACalc.js b/jsinfo/createACalc.js new file mode 100644 index 0000000..ac12bf2 --- /dev/null +++ b/jsinfo/createACalc.js @@ -0,0 +1,20 @@ +// Create an object calculator with three methods: read , sum, mul + +let calculator = { + read() { + this.value1 = parseFloat(prompt("what is the first value")); + this.value2 = parseFloat(prompt("what is the second value")); + }, + + sum() { + return this.value1 + this.value2; + }, + + mul() { + return this.value1 * this.value2; + } +} + +calculator.read(); +alert( calculator.sum() ); +alert( calculator.mul() ); diff --git a/jsinfo/helloObject.js b/jsinfo/helloObject.js new file mode 100644 index 0000000..4c037f7 --- /dev/null +++ b/jsinfo/helloObject.js @@ -0,0 +1,15 @@ +//Hello, object + +//Creating an object + + + +let user = { + name : "John", + surname : "Smith" +}; +// reassign name to "Pete" + +user.name = "Pete"; +// Delete the property of name +delete user.name; diff --git a/jsinfo/multiplyNumericByTwo.js b/jsinfo/multiplyNumericByTwo.js new file mode 100644 index 0000000..fd901ce --- /dev/null +++ b/jsinfo/multiplyNumericByTwo.js @@ -0,0 +1,23 @@ +/* Create a function multiplyNumeric(obj) that multiplies + all numeric properties of obj by 2.*/ + + function multiplyNumeric(obj) { + //gets values of the keys in the object + for (let key in obj) { + /*makes sure that the type of is number + so you can actually multiply by two*/ + if (typeof obj[key] === 'number') { + obj[key] *= 2; + } + } + } + +//example object + let menu = { + width: 200, + height: 300, + title: "My menu" + }; + +//call the function + multiplyNumeric(menu) From 0cb9ebe706582930cc13295ec750350152461021 Mon Sep 17 00:00:00 2001 From: Alex Reany Date: Mon, 24 Apr 2017 17:45:50 -0700 Subject: [PATCH 2/6] finished stage 1 --- bike-shop/src/stage1-literals.js | 20 ++++++++++++++++++-- index.html | 2 +- jsinfo/chaining.js | 1 - jsinfo/createNewAccumlator.js | 28 ++++++++++++++++++++++++++++ jsinfo/createNewCalc.js | 29 +++++++++++++++++++++++++++++ 5 files changed, 76 insertions(+), 4 deletions(-) create mode 100644 jsinfo/createNewAccumlator.js create mode 100644 jsinfo/createNewCalc.js diff --git a/bike-shop/src/stage1-literals.js b/bike-shop/src/stage1-literals.js index c749dd2..e18a7e2 100644 --- a/bike-shop/src/stage1-literals.js +++ b/bike-shop/src/stage1-literals.js @@ -1,5 +1,21 @@ const myBike = { - // your code here -} + + name : "Roadster", + price : 199.99, + frame : { + color : "blue", + height: 55, + style : "cruiser" + }, + brakes : { + back : true, + front : false + }, + tires : { + diameter : 22, + type : "fat" + }, + rings : [2, 5] +}; module.exports = myBike diff --git a/index.html b/index.html index 449f707..086ca1a 100644 --- a/index.html +++ b/index.html @@ -5,6 +5,6 @@ - + diff --git a/jsinfo/chaining.js b/jsinfo/chaining.js index e7247ad..4a7e52d 100644 --- a/jsinfo/chaining.js +++ b/jsinfo/chaining.js @@ -35,7 +35,6 @@ let ladder = { down() { this.step--; return this; - }, // shows the current step showStep: function() { diff --git a/jsinfo/createNewAccumlator.js b/jsinfo/createNewAccumlator.js new file mode 100644 index 0000000..c7f06f8 --- /dev/null +++ b/jsinfo/createNewAccumlator.js @@ -0,0 +1,28 @@ +/*Create a constructor function Accumulator(startingValue). + +Object that it creates should: + +Store the “current value” in the property value. The starting value is set to the argument of the constructor startingValue. +The read() method should use prompt to read a new number and add it to value. +In other words, the value property is the sum of all user-entered values with the initial value startingValue. +*/ + + +function Accumulator(startingValue) { + + this.read = function () { + this.value1 = parseFloat(prompt("what is the first value")); + startingValue += this.value1; + console.log(startingValue); + }; + + this.value = function (startingValue) { + return Accumulator.startingValue + } +} + + +let accumulator = new Accumulator(1); // initial value 1 +accumulator.read(); // adds the user-entered value +accumulator.read(); // adds the user-entered value +alert(accumulator.value); // shows the sum of these values diff --git a/jsinfo/createNewCalc.js b/jsinfo/createNewCalc.js new file mode 100644 index 0000000..836aa8c --- /dev/null +++ b/jsinfo/createNewCalc.js @@ -0,0 +1,29 @@ +/*Create a constructor function Calculator +that creates objects with 3 methods: +read() sum() mul() */ + +function Calculator() { + + this.read = function () { + this.value1 = parseFloat(prompt("what is the first value")); + this.value2 = parseFloat(prompt("what is the second value")); + }; + + this.sum = function () { + this.sumResults = this.value1 + this.value2; + return this.sumResults; + }; + + this.mul = function () { + this.mulResults = this.value1 * this.value2; + return this.mulResults; + }; + +} + +let calculator = new Calculator(); + +calculator.read(); + +alert( "Sum=" + calculator.sum() ); +alert( "Mul=" + calculator.mul() ); From f9eaf5363eb65062fcf2cbc303b15df1df80aaaa Mon Sep 17 00:00:00 2001 From: Alex Reany Date: Tue, 25 Apr 2017 11:39:13 -0700 Subject: [PATCH 3/6] finished stage 2 --- bike-shop/src/stage2-constructors.js | 43 ++++++++++++++++++++++++---- index.html | 2 +- jsinfo/createNewAccumlator.js | 11 +++---- jsinfo/extendableCalculator.js | 40 ++++++++++++++++++++++++++ jsinfo/searthingAlgo.js | 0 5 files changed, 82 insertions(+), 14 deletions(-) create mode 100644 jsinfo/extendableCalculator.js create mode 100644 jsinfo/searthingAlgo.js diff --git a/bike-shop/src/stage2-constructors.js b/bike-shop/src/stage2-constructors.js index c422386..b52ede6 100644 --- a/bike-shop/src/stage2-constructors.js +++ b/bike-shop/src/stage2-constructors.js @@ -1,17 +1,48 @@ -function Bike() { - // your code here +function Bike(name, price) { + alert(new.target); + this.name = name + this.price = price + this.rings = [3, 7] + this.brakes = { + back : true, + front : true + }, + this.tires = [new Tire, new Tire] + this.frame = new Frame } -function Frame() { - // your code here +function Frame(color, size, style) { + this.color = color ? color : "black" + this.size = size ? size : 55 + this.style = style ? style : "street" } -function Tire() { - // your code here +function Tire(diameter, type) { + this.diameter = diameter ? diameter : 22 + this.type = type ? type : 'street' + this.rings = [2, 5] } + module.exports = { Bike: Bike, Frame: Frame, Tire: Tire } + + + + +const myFrame = new Frame() +//myFrame.color = "black" +//myFrame.size = 55 +//myFrame.style = "street" + +const myBike = new Bike() +//myBike.name = "" +//myBike.price = "" +//myBike.tires = ["front", "back"] + +const myTire = new Tire() +//myTire.diameter = "" +//myTire.type = "" diff --git a/index.html b/index.html index 086ca1a..d873de8 100644 --- a/index.html +++ b/index.html @@ -5,6 +5,6 @@ - + diff --git a/jsinfo/createNewAccumlator.js b/jsinfo/createNewAccumlator.js index c7f06f8..dceab73 100644 --- a/jsinfo/createNewAccumlator.js +++ b/jsinfo/createNewAccumlator.js @@ -9,16 +9,13 @@ In other words, the value property is the sum of all user-entered values with th function Accumulator(startingValue) { + //holds the startingValue to be minipulated + this.value = startingValue; this.read = function () { - this.value1 = parseFloat(prompt("what is the first value")); - startingValue += this.value1; - console.log(startingValue); + //adds the prompted amount to the value at the moment + this.value += parseFloat(prompt("what is the first value")); }; - - this.value = function (startingValue) { - return Accumulator.startingValue - } } diff --git a/jsinfo/extendableCalculator.js b/jsinfo/extendableCalculator.js new file mode 100644 index 0000000..3c975a7 --- /dev/null +++ b/jsinfo/extendableCalculator.js @@ -0,0 +1,40 @@ +//Create a calculator that can take a string and return the value +function Calculator() { + + let methods = { + "+" : function(value1, value2){ + return parseFloat(value1) + parseFloat(value2) + }, + //arrow function + "-" : (value1, value2) => parseFloat(value1) - parseFloat(value2), + } + + this.calculate = function (str) { + + let strSplit = str.split(" "); + var value1 = strSplit[0]; + var value2 = strSplit[2]; + var operator = strSplit[1]; + + return methods[operator](value1, value2) + }; + + this.addOperator =function (name, func){ + methods[name] = func; + } +} + +let calc = new Calculator; + +alert( calc.calculate("3 + 7") ); // 10 + +let newCalc = new Calculator + +newCalc.addOperator("*", (a, b) => a * b); +newCalc.addOperator("/", (a, b) => a / b); +newCalc.addOperator("**", (a, b) => a ** b) +newCalc.addOperator("pie", (a,b) => "I have " + a + " pies cut into " + b + " slices each") +alert(newCalc.calculate("2 * 3")); //6 +alert(newCalc.calculate("2 ** 3")); //8 +alert(newCalc.calculate("6 / 2")); //3 +alert(newCalc.calculate("7 pie 4")); diff --git a/jsinfo/searthingAlgo.js b/jsinfo/searthingAlgo.js new file mode 100644 index 0000000..e69de29 From 023bd6c18bc50ddc49301363cf61800644d0b80f Mon Sep 17 00:00:00 2001 From: Alex Reany Date: Tue, 25 Apr 2017 11:43:41 -0700 Subject: [PATCH 4/6] cleaning up branches --- jsinfo/searthingAlgo.js | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/jsinfo/searthingAlgo.js b/jsinfo/searthingAlgo.js index e69de29..05d877f 100644 --- a/jsinfo/searthingAlgo.js +++ b/jsinfo/searthingAlgo.js @@ -0,0 +1,22 @@ +/* +Use __proto__ to assign prototypes in a way that any property +lookup will follow the path: pockets → bed → table → head. For instance, +pockets.pen should be 3 (found in table), and bed.glasses should be 1 (found in head). +*/ + +let head = { + glasses: 1 +}; + +let table = { + pen: 3 +}; + +let bed = { + sheet: 1, + pillow: 2 +}; + +let pockets = { + money: 2000 +}; From d1cf8821d3569183ae4de71b76e466c384751f38 Mon Sep 17 00:00:00 2001 From: Alex Reany Date: Wed, 26 Apr 2017 08:17:52 -0700 Subject: [PATCH 5/6] work in progress --- bike-shop/src/stage3-methods.js | 41 ++++++++++++++++- index.html | 2 +- jsinfo/createACalc.js | 1 + jsinfo/createNewCalc.js | 1 + jsinfo/errorInInheritance.js | 27 +++++++++++ jsinfo/extendableCalculator.js | 2 + jsinfo/rewritePrototype.js | 79 ++++++++++++++++++++++++++++++++ jsinfo/rewriteToClass.js | 81 +++++++++++++++++++++++++++++++++ jsinfo/searthingAlgo.js | 15 ++++-- jsinfo/twoHamsters.js | 30 ++++++++++++ 10 files changed, 273 insertions(+), 6 deletions(-) create mode 100644 jsinfo/errorInInheritance.js create mode 100644 jsinfo/rewritePrototype.js create mode 100644 jsinfo/rewriteToClass.js create mode 100644 jsinfo/twoHamsters.js diff --git a/bike-shop/src/stage3-methods.js b/bike-shop/src/stage3-methods.js index c422386..cd42d4e 100644 --- a/bike-shop/src/stage3-methods.js +++ b/bike-shop/src/stage3-methods.js @@ -6,8 +6,8 @@ function Frame() { // your code here } -function Tire() { - // your code here +function Tire(isFlat) { + isFlat : isFlat } module.exports = { @@ -15,3 +15,40 @@ module.exports = { Frame: Frame, Tire: Tire } + + +Tire.prototype.isFlat = function () { + this.isFlat = false; + return this.isFlat +} + +Tire.prototype.puncture = function () { + this.isFlat = true; + return this +} + +Tire.prototype.repair = function () { + this.isFlat = false; + return this +} + +Bike.prototype.isMoving = function () { + return false +} + +Bike.prototype.pedal = function () { + +} + +Bike.prototype.brake = function () { + +} + +Bike.prototype.gearSpeeds = function () { + +} + + + +const myTire = new Tire +const myBike = new Bike diff --git a/index.html b/index.html index d873de8..2223032 100644 --- a/index.html +++ b/index.html @@ -5,6 +5,6 @@ - + diff --git a/jsinfo/createACalc.js b/jsinfo/createACalc.js index ac12bf2..d852b06 100644 --- 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 index 836aa8c..a3922fe 100644 --- 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 new file mode 100644 index 0000000..589f8d2 --- /dev/null +++ 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 index 3c975a7..7695075 100644 --- 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 new file mode 100644 index 0000000..44af2da --- /dev/null +++ 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 new file mode 100644 index 0000000..21edd44 --- /dev/null +++ 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 b/jsinfo/searthingAlgo.js index 05d877f..9d95d9e 100644 --- a/jsinfo/searthingAlgo.js +++ b/jsinfo/searthingAlgo.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 new file mode 100644 index 0000000..6703176 --- /dev/null +++ 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 From b4160354a5a218c3864e6ecd9ec6a1746b830ca0 Mon Sep 17 00:00:00 2001 From: Alex Reany Date: Wed, 26 Apr 2017 10:57:24 -0700 Subject: [PATCH 6/6] finalized stage 3 --- bike-shop/src/stage2-constructors.js | 1 - bike-shop/src/stage3-methods.js | 54 ++++++++++++------- jsinfo/{searthingAlgo.js => searchingAlgo.js} | 2 +- 3 files changed, 35 insertions(+), 22 deletions(-) rename jsinfo/{searthingAlgo.js => searchingAlgo.js} (93%) diff --git a/bike-shop/src/stage2-constructors.js b/bike-shop/src/stage2-constructors.js index b52ede6..4c26afb 100644 --- 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 index cd42d4e..2f2fc5a 100644 --- a/bike-shop/src/stage3-methods.js +++ b/bike-shop/src/stage3-methods.js @@ -1,54 +1,68 @@ 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(isFlat) { - isFlat : isFlat +function Tire() { + this._isFlat = false } -module.exports = { - Bike: Bike, - Frame: Frame, - Tire: Tire -} + Tire.prototype.isFlat = function () { - this.isFlat = false; - return this.isFlat + return this._isFlat } Tire.prototype.puncture = function () { - this.isFlat = true; - return this + this._isFlat = true + //this.tires[0]._isFlat = true } + Tire.prototype.repair = function () { - this.isFlat = false; - return this + this._isFlat = false; } Bike.prototype.isMoving = function () { - return false + 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 +const myTire = new Tire() +const myBike = new Bike() + +module.exports = { + Bike: Bike, + Frame: Frame, + Tire: Tire +} diff --git a/jsinfo/searthingAlgo.js b/jsinfo/searchingAlgo.js similarity index 93% rename from jsinfo/searthingAlgo.js rename to jsinfo/searchingAlgo.js index 9d95d9e..7e9c08b 100644 --- a/jsinfo/searthingAlgo.js +++ b/jsinfo/searchingAlgo.js @@ -28,4 +28,4 @@ let pockets = { or head.glasses? Benchmark if needed.*/ //It seems that pocket.glasses and head.glasses -//take about the same amout of time +//take about the same amout of time