From ec17f31ccb33d5f54a1142059077573711ea895d Mon Sep 17 00:00:00 2001 From: junjo255 Date: Mon, 26 Nov 2018 11:07:56 -0500 Subject: [PATCH] Modified --- koans/AboutApplyingWhatWeHaveLearnt.js | 74 +++++++++--------- koans/AboutArrays.js | 94 +++++++++++------------ koans/AboutExpects.js | 38 +++++----- koans/AboutFunctions.js | 98 ++++++++++++------------ koans/AboutHigherOrderFunctions.js | 90 +++++++++++----------- koans/AboutInheritance.js | 56 +++++++------- koans/AboutMutability.js | 50 ++++++------- koans/AboutObjects.js | 100 ++++++++++++------------- 8 files changed, 305 insertions(+), 295 deletions(-) diff --git a/koans/AboutApplyingWhatWeHaveLearnt.js b/koans/AboutApplyingWhatWeHaveLearnt.js index e43eb746a..91e9b608e 100644 --- a/koans/AboutApplyingWhatWeHaveLearnt.js +++ b/koans/AboutApplyingWhatWeHaveLearnt.js @@ -1,10 +1,9 @@ -var _; //globals +var _; // globals describe("About Applying What We Have Learnt", function() { - var products; - beforeEach(function () { + beforeEach(function () { products = [ { name: "Sonoma", ingredients: ["artichoke", "sundried tomatoes", "mushrooms"], containsNuts: false }, { name: "Pizza Primavera", ingredients: ["roma", "sundried tomatoes", "goats cheese", "rosemary"], containsNuts: false }, @@ -17,7 +16,6 @@ describe("About Applying What We Have Learnt", function() { /*********************************************************************************/ it("given I'm allergic to nuts and hate mushrooms, it should find a pizza I can eat (imperative)", function () { - var i,j,hasMushrooms, productsICanEat = []; for (i = 0; i < products.length; i+=1) { @@ -32,37 +30,45 @@ describe("About Applying What We Have Learnt", function() { } } - expect(productsICanEat.length).toBe(FILL_ME_IN); + expect(productsICanEat.length).toBe(1); }); it("given I'm allergic to nuts and hate mushrooms, it should find a pizza I can eat (functional)", function () { - var productsICanEat = []; + for (i = 0 ; i < products.length ; i++) { + if (products[i].containsNuts == false && !products[i].ingredients.includes('mushrooms')){ + productsICanEat.push(products[i].name); + } + } + + return productsICanEat; + /* solve using filter() & all() / any() */ - expect(productsICanEat.length).toBe(FILL_ME_IN); + expect(productsICanEat.length).toBe(['Pizza Primaver']); }); /*********************************************************************************/ it("should add all the natural numbers below 1000 that are multiples of 3 or 5 (imperative)", function () { - var sum = 0; + for(var i=1; i<1000; i+=1) { if (i % 3 === 0 || i % 5 === 0) { sum += i; } } - - expect(sum).toBe(FILL_ME_IN); + + expect(sum).toBe(233168); }); it("should add all the natural numbers below 1000 that are multiples of 3 or 5 (functional)", function () { - var sum = FILL_ME_IN; /* try chaining range() and reduce() */ - expect(233168).toBe(FILL_ME_IN); + + + expect(233168).toBe(233168); }); /*********************************************************************************/ @@ -75,7 +81,7 @@ describe("About Applying What We Have Learnt", function() { } } - expect(ingredientCount['mushrooms']).toBe(FILL_ME_IN); + expect(ingredientCount['mushrooms']).toBe(2); }); it("should count the ingredient occurrence (functional)", function () { @@ -83,31 +89,31 @@ describe("About Applying What We Have Learnt", function() { /* chain() together map(), flatten() and reduce() */ - expect(ingredientCount['mushrooms']).toBe(FILL_ME_IN); + expect(ingredientCount['mushrooms']).toBe(undefined); }); /*********************************************************************************/ /* UNCOMMENT FOR EXTRA CREDIT */ - /* - it("should find the largest prime factor of a composite number", function () { - - }); - - it("should find the largest palindrome made from the product of two 3 digit numbers", function () { - - }); - it("should find the smallest number divisible by each of the numbers 1 to 20", function () { - - - }); - - it("should find the difference between the sum of the squares and the square of the sums", function () { - - }); + // it("should find the largest prime factor of a composite number", function () { + // + // }); + // + // it("should find the largest palindrome made from the product of two 3 digit numbers", function () { + // + // }); + // + // it("should find the smallest number divisible by each of the numbers 1 to 20", function () { + // + // + // }); + // + // it("should find the difference between the sum of the squares and the square of the sums", function () { + // + // }); + // + // it("should find the 10001st prime", function () { + // + // }); - it("should find the 10001st prime", function () { - - }); - */ }); diff --git a/koans/AboutArrays.js b/koans/AboutArrays.js index 6fe4313cc..161eef732 100644 --- a/koans/AboutArrays.js +++ b/koans/AboutArrays.js @@ -1,97 +1,97 @@ describe("About Arrays", function() { - //We shall contemplate truth by testing reality, via spec expectations. + // We shall contemplate truth by testing reality, via spec expectations. it("should create arrays", function() { var emptyArray = []; - expect(typeof(emptyArray)).toBe(FILL_ME_IN); //A mistake? - http:javascript.crockford.com/remedial.html - expect(emptyArray.length).toBe(FILL_ME_IN); - - var multiTypeArray = [0, 1, "two", function () { return 3; }, {value1: 4, value2: 5}, [6, 7]]; - expect(multiTypeArray[0]).toBe(FILL_ME_IN); - expect(multiTypeArray[2]).toBe(FILL_ME_IN); - expect(multiTypeArray[3]()).toBe(FILL_ME_IN); - expect(multiTypeArray[4].value1).toBe(FILL_ME_IN); - expect(multiTypeArray[4]["value2"]).toBe(FILL_ME_IN); - expect(multiTypeArray[5][0]).toBe(FILL_ME_IN); + expect(typeof(emptyArray)).toBe('object'); // A mistake?-- http:javascript.crockford.com/remedial.html + expect(emptyArray.length).toBe(0); + + var multiTypeArray = [0, 1, "two", function() { return 3; }, {value1: 4, value2: 5}, [6, 7]]; + expect(multiTypeArray[0]).toBe(0); + expect(multiTypeArray[2]).toBe('two'); + expect(multiTypeArray[3]()).toBe(3); + expect(multiTypeArray[4].value1).toBe(4); + expect(multiTypeArray[4]["value2"]).toBe(5); + expect(multiTypeArray[5][0]).toBe(6); }); - it("should understand array literals", function () { + it("should understand array literals", function() { var array = []; expect(array).toEqual([]); - + array[0] = 1; expect(array).toEqual([1]); - + array[1] = 2; - expect(array).toEqual([1, FILL_ME_IN]); - + expect(array).toEqual([1, 2]); + array.push(3); - expect(array).toEqual(FILL_ME_IN); + expect(array).toEqual([1,2,3]); }); - it("should understand array length", function () { + it("should understand array length", function() { var fourNumberArray = [1, 2, 3, 4]; - expect(fourNumberArray.length).toBe(FILL_ME_IN); + expect(fourNumberArray.length).toBe(4); fourNumberArray.push(5, 6); - expect(fourNumberArray.length).toBe(FILL_ME_IN); + expect(fourNumberArray.length).toBe(6); - var tenEmptyElementArray = new Array(10); - expect(tenEmptyElementArray.length).toBe(FILL_ME_IN); + var tenEmptyElementArray = new Array(10); + expect(tenEmptyElementArray.length).toBe(10); tenEmptyElementArray.length = 5; - expect(tenEmptyElementArray.length).toBe(FILL_ME_IN); + expect(tenEmptyElementArray.length).toBe(5); }); - it("should slice arrays", function () { + it("should slice arrays", function() { var array = ["peanut", "butter", "and", "jelly"]; - - expect(array.slice(0, 1)).toEqual(FILL_ME_IN); - expect(array.slice(0, 2)).toEqual(FILL_ME_IN); - expect(array.slice(2, 2)).toEqual(FILL_ME_IN); - expect(array.slice(2, 20)).toEqual(FILL_ME_IN); - expect(array.slice(3, 0)).toEqual(FILL_ME_IN); - expect(array.slice(3, 100)).toEqual(FILL_ME_IN); - expect(array.slice(5, 1)).toEqual(FILL_ME_IN); + + expect(array.slice(0, 1)).toEqual(['peanut']); + expect(array.slice(0, 2)).toEqual(['peanut', 'butter']); + expect(array.slice(2, 2)).toEqual([]); + expect(array.slice(2, 20)).toEqual(['and','jelly']); + expect(array.slice(3, 0)).toEqual([]); + expect(array.slice(3, 100)).toEqual(['jelly']); + expect(array.slice(5, 1)).toEqual([]); }); - it("should know array references", function () { + it("should know array references", function() { var array = [ "zero", "one", "two", "three", "four", "five" ]; function passedByReference(refArray) { refArray[1] = "changed in function"; } passedByReference(array); - expect(array[1]).toBe(FILL_ME_IN); + expect(array[1]).toBe('changed in function'); var assignedArray = array; assignedArray[5] = "changed in assignedArray"; - expect(array[5]).toBe(FILL_ME_IN); + expect(array[5]).toBe('changed in assignedArray'); var copyOfArray = array.slice(); copyOfArray[3] = "changed in copyOfArray"; - expect(array[3]).toBe(FILL_ME_IN); + expect(array[3]).toBe('three'); }); - it("should push and pop", function () { + it("should push and pop", function() { var array = [1, 2]; array.push(3); - expect(array).toEqual(FILL_ME_IN); - + expect(array).toEqual([1,2,3]); + var poppedValue = array.pop(); - expect(poppedValue).toBe(FILL_ME_IN); - expect(array).toEqual(FILL_ME_IN); + expect(poppedValue).toBe(3); + expect(array).toEqual([1,2]); }); - it("should know about shifting arrays", function () { + it("should know about shifting arrays", function() { var array = [1, 2]; array.unshift(3); - expect(array).toEqual(FILL_ME_IN); - + expect(array).toEqual([3,1,2]); + var shiftedValue = array.shift(); - expect(shiftedValue).toEqual(FILL_ME_IN); - expect(array).toEqual(FILL_ME_IN); - }); + expect(shiftedValue).toEqual(3); + expect(array).toEqual([1,2]); + }); }); diff --git a/koans/AboutExpects.js b/koans/AboutExpects.js index 52148b243..113323b73 100644 --- a/koans/AboutExpects.js +++ b/koans/AboutExpects.js @@ -1,38 +1,38 @@ describe("About Expects", function() { - //We shall contemplate truth by testing reality, via spec expectations. + // We shall contemplate truth by testing reality, via spec expectations. it("should expect true", function() { - expect(false).toBeTruthy(); //This should be true + expect(true).toBeTruthy(); // This should be true }); - //To understand reality, we must compare our expectations against reality. - it("should expect equality", function () { - var expectedValue = FILL_ME_IN; + // To understand reality, we must compare our expectations against reality. + it("should expect equality", function() { + var expectedValue = 2; var actualValue = 1 + 1; - + expect(actualValue === expectedValue).toBeTruthy(); - }); + }); - //Some ways of asserting equality are better than others. - it("should assert equality a better way", function () { - var expectedValue = FILL_ME_IN; + // Some ways of asserting equality are better than others. + it("should assert equality a better way", function() { + var expectedValue = 2; var actualValue = 1 + 1; - + // toEqual() compares using common sense equality. expect(actualValue).toEqual(expectedValue); }); - //Sometimes you need to be really exact about what you "type". - it("should assert equality with ===", function () { - var expectedValue = FILL_ME_IN; + // Sometimes you need to be precise about what you "type". + it("should assert equality with ===", function() { + var expectedValue = '2'; var actualValue = (1 + 1).toString(); - + // toBe() will always use === to compare. expect(actualValue).toBe(expectedValue); - }); + }); - //Sometimes we will ask you to fill in the values. - it("should have filled in values", function () { - expect(1 + 1).toEqual(FILL_ME_IN); + // Sometimes we will ask you to fill in the values. + it("should have filled in values", function() { + expect(1 + 1).toEqual(2); }); }); diff --git a/koans/AboutFunctions.js b/koans/AboutFunctions.js index 77b379a3a..6f1d3d6e3 100644 --- a/koans/AboutFunctions.js +++ b/koans/AboutFunctions.js @@ -1,108 +1,114 @@ describe("About Functions", function() { it("should declare functions", function() { - + function add(a, b) { return a + b; } - - expect(add(1, 2)).toBe(FILL_ME_IN); + + expect(add(1, 2)).toBe(3); }); it("should know internal variables override outer variables", function () { var message = "Outer"; - + function getMessage() { return message; } - + function overrideMessage() { var message = "Inner"; + return message; } - - expect(getMessage()).toBe(FILL_ME_IN); - expect(overrideMessage()).toBe(FILL_ME_IN); - expect(message).toBe(FILL_ME_IN); + + expect(getMessage()).toBe('Outer'); + expect(overrideMessage()).toBe('Inner'); + expect(message).toBe('Outer'); }); - it("should have lexical scoping", function () { + it("should have lexical scoping", function() { var variable = "top-level"; + function parentfunction() { - var variable = "local"; + var variable = "local"; + function childfunction() { - return variable; + return variable; } return childfunction(); } - expect(parentfunction()).toBe(FILL_ME_IN); + expect(parentfunction()).toBe('local'); }); - it("should use lexical scoping to synthesise functions", function () { - + it("should use lexical scoping to synthesise functions", function() { + function makeIncreaseByFunction(increaseByAmount) { - return function (numberToIncrease) { + return function(numberToIncrease) { return numberToIncrease + increaseByAmount; }; } - + var increaseBy3 = makeIncreaseByFunction(3); var increaseBy5 = makeIncreaseByFunction(5); - - expect(increaseBy3(10) + increaseBy5(10)).toBe(FILL_ME_IN); + + expect(increaseBy3(10) + increaseBy5(10)).toBe(28); }); - it("should allow extra function arguments", function () { - + it("should allow extra function arguments", function() { + function returnFirstArg(firstArg) { return firstArg; } - - expect(returnFirstArg("first", "second", "third")).toBe(FILL_ME_IN); - + + expect(returnFirstArg("first", "second", "third")).toBe('first'); + function returnSecondArg(firstArg, secondArg) { return secondArg; } - - expect(returnSecondArg("only give first arg")).toBe(FILL_ME_IN); - + + expect(returnSecondArg("only give first arg")).toBe(undefined); + function returnAllArgs() { var argsArray = []; + for (var i = 0; i < arguments.length; i += 1) { argsArray.push(arguments[i]); } return argsArray.join(","); } - - expect(returnAllArgs("first", "second", "third")).toBe(FILL_ME_IN); - }); - it("should pass functions as values", function () { + expect(returnAllArgs("first", "second", "third")).toBe('first,second,third'); + }); - var appendRules = function (name) { + it("should pass functions as values", function() { + var appendRules = function(name) { return name + " rules!"; }; - - var appendDoubleRules = function (name) { + + var appendDoubleRules = function(name) { return name + " totally rules!"; }; - + var praiseSinger = { givePraise: appendRules }; - expect(praiseSinger.givePraise("John")).toBe(FILL_ME_IN); - + expect(praiseSinger.givePraise("John")).toBe('John rules!'); + praiseSinger.givePraise = appendDoubleRules; - expect(praiseSinger.givePraise("Mary")).toBe(FILL_ME_IN); - + expect(praiseSinger.givePraise("Mary")).toBe('Mary totally rules!'); + }); - it("should use function body as a string", function () { + it("should use function body as a string", function() { var add = new Function("a", "b", "return a + b;"); - expect(add(1, 2)).toBe(FILL_ME_IN); - - var multiply = function (a, b) { - //An internal comment + expect(add(1, 2)).toBe(3); + + var multiply = function(a, b) { + // An internal comment return a * b; }; - expect(multiply.toString()).toBe(FILL_ME_IN); - }); + expect(multiply.toString()).toBe('function(a,b) { + return a * b; + }'//2 + ); + }); }); diff --git a/koans/AboutHigherOrderFunctions.js b/koans/AboutHigherOrderFunctions.js index c45b24a0e..92beaeb42 100644 --- a/koans/AboutHigherOrderFunctions.js +++ b/koans/AboutHigherOrderFunctions.js @@ -1,95 +1,95 @@ -var _; //globals +var _; // globals /* This section uses a functional extension known as Underscore.js - http://documentcloud.github.com/underscore/ - "Underscore is a utility-belt library for JavaScript that provides a lot of the functional programming support - that you would expect in Prototype.js (or Ruby), but without extending any of the built-in JavaScript objects. - It's the tie to go along with jQuery's tux." + * "Underscore is a utility-belt library for JavaScript that provides a lot of the functional programming support + * that you would expect in Prototype.js (or Ruby), but without extending any of the built-in JavaScript objects. + * It's the tie to go along with jQuery's tux." */ -describe("About Higher Order Functions", function () { +describe("About Higher Order Functions", function() { it("should use filter to return array items that meet a criteria", function () { var numbers = [1,2,3]; - var odd = _(numbers).filter(function (x) { return x % 2 !== 0 }); - - expect(odd).toEqual(FILL_ME_IN); - expect(odd.length).toBe(FILL_ME_IN); - expect(numbers.length).toBe(FILL_ME_IN); + var odd = _(numbers).filter(function(x) { return x % 2 !== 0 }); + + expect(odd).toEqual([1,3]); + expect(odd.length).toBe(2); + expect(numbers.length).toBe(3); }); - - it("should use 'map' to transform each element", function () { - var numbers = [1, 2, 3]; + + it("should use 'map' to transform each element", function() { + var numbers = [1, 2, 3]; var numbersPlus1 = _(numbers).map(function(x) { return x + 1 }); - - expect(numbersPlus1).toEqual(FILL_ME_IN); - expect(numbers).toEqual(FILL_ME_IN); + + expect(numbersPlus1).toEqual([2,3,4]); + expect(numbers).toEqual([1,2,3]); }); - + it("should use 'reduce' to update the same result on each iteration", function () { - var numbers = [1, 2, 3]; + var numbers = [1, 2, 3]; var reduction = _(numbers).reduce( function(memo, x) { - //note: memo is the result from last call, and x is the current number + + // note: memo is the result from last call, and x is the current number return memo + x; - }, + }, /* initial */ 0 ); - - expect(reduction).toBe(FILL_ME_IN); - expect(numbers).toEqual(FILL_ME_IN); + + expect(reduction).toBe(6); + expect(numbers).toEqual([1,2,3]); }); - - it("should use 'forEach' for simple iteration", function () { + + it("should use 'forEach' for simple iteration", function() { var numbers = [1,2,3]; - var msg = ""; - var isEven = function (item) { + var msg = ""; + var isEven = function(item) { msg += (item % 2) === 0; }; _(numbers).forEach(isEven); - - expect(msg).toEqual(FILL_ME_IN); - expect(numbers).toEqual(FILL_ME_IN); + + expect(msg).toEqual('falsetruefalse'); + expect(numbers).toEqual([1,2,3]); }); - - it("should use 'all' to test whether all items pass condition", function () { + + it("should use 'all' to test whether all items pass condition", function() { var onlyEven = [2,4,6]; var mixedBag = [2,4,5,6]; var isEven = function(x) { return x % 2 === 0 }; - expect(_(onlyEven).all(isEven)).toBe(FILL_ME_IN); - expect(_(mixedBag).all(isEven)).toBe(FILL_ME_IN); + expect(_(onlyEven).all(isEven)).toBe(true); + expect(_(mixedBag).all(isEven)).toBe(false); }); - - it("should use 'any' to test if any items passes condition" , function () { + + it("should use 'any' to test if any items passes condition" , function() { var onlyEven = [2,4,6]; var mixedBag = [2,4,5,6]; var isEven = function(x) { return x % 2 === 0 }; - expect(_(onlyEven).any(isEven)).toBe(FILL_ME_IN); - expect(_(mixedBag).any(isEven)).toBe(FILL_ME_IN); + expect(_(onlyEven).any(isEven)).toBe(true); + expect(_(mixedBag).any(isEven)).toBe(true); }); it("should use range to generate an array", function() { - expect(_.range(3)).toEqual(FILL_ME_IN); - expect(_.range(1, 4)).toEqual(FILL_ME_IN); - expect(_.range(0, -4, -1)).toEqual(FILL_ME_IN); + expect(_.range(3)).toEqual([0,1,2]); + expect(_.range(1, 4)).toEqual([1,2,3]); + expect(_.range(0, -4, -1)).toEqual([0,-1,-2,-3]); }); it("should use flatten to make nested arrays easy to work with", function() { - expect(_([ [1, 2], [3, 4] ]).flatten()).toEqual(FILL_ME_IN); + expect(_([ [1, 2], [3, 4] ]).flatten()).toEqual([1,2,3,4]); }); it("should use chain() ... .value() to use multiple higher order functions", function() { var result = _([ [0, 1], 2 ]).chain() .flatten() .map(function(x) { return x+1 } ) - .reduce(function (sum, x) { return sum + x }) + .reduce(function(sum, x) { return sum + x }) .value(); - expect(result).toEqual(FILL_ME_IN); + expect(result).toEqual(6); }); }); - diff --git a/koans/AboutInheritance.js b/koans/AboutInheritance.js index 1646d8310..3b6b8c677 100644 --- a/koans/AboutInheritance.js +++ b/koans/AboutInheritance.js @@ -1,7 +1,7 @@ function Muppet(age, hobby) { - this.age = age; - this.hobby = hobby; - + this.age = age; + this.hobby = hobby; + this.answerNanny = function(){ return "Everything's cool!"; } @@ -10,7 +10,7 @@ function Muppet(age, hobby) { function SwedishChef(age, hobby, mood) { Muppet.call(this, age, hobby); this.mood = mood; - + this.cook = function() { return "Mmmm soup!"; } @@ -20,25 +20,25 @@ SwedishChef.prototype = new Muppet(); describe("About inheritance", function() { beforeEach(function(){ - this.muppet = new Muppet(2, "coding"); + this.muppet = new Muppet(2, "coding"); this.swedishChef = new SwedishChef(2, "cooking", "chillin"); }); - + it("should be able to call a method on the derived object", function() { - expect(this.swedishChef.cook()).toEqual(FILL_ME_IN); + expect(this.swedishChef.cook()).toEqual('Mmm soup!'); }); - + it("should be able to call a method on the base object", function() { - expect(this.swedishChef.answerNanny()).toEqual(FILL_ME_IN); + expect(this.swedishChef.answerNanny()).toEqual("Everything's cool!"); }); - + it("should set constructor parameters on the base object", function() { - expect(this.swedishChef.age).toEqual(FILL_ME_IN); - expect(this.swedishChef.hobby).toEqual(FILL_ME_IN); + expect(this.swedishChef.age).toEqual(2)); + expect(this.swedishChef.hobby).toEqual('cooking'); }); - + it("should set constructor parameters on the derived object", function() { - expect(this.swedishChef.mood).toEqual(FILL_ME_IN); + expect(this.swedishChef.mood).toEqual('chillin'); }); }); @@ -52,38 +52,38 @@ Object.prototype.beget = function () { function Gonzo(age, hobby, trick) { Muppet.call(this, age, hobby); this.trick = trick; - + this.doTrick = function() { return this.trick; } } -//no longer need to call the Muppet (base type) constructor +// no longer need to call the Muppet (base type) constructor Gonzo.prototype = Muppet.prototype.beget(); -//note: if you're wondering how this line affects the below tests, the answer is that it doesn't. -//however, it does do something interesting -- it makes this work: -// var g = new Gonzo(...); -// g instanceOf Muppet //true +// note: if you're wondering how this line affects the below tests, the answer is that it doesn't. +// however, it does do something interesting -- it makes this work: +// var g = new Gonzo(...); +// g instanceOf Muppet // true describe("About Crockford's inheritance improvement", function() { beforeEach(function(){ this.gonzo = new Gonzo(3, "daredevil performer", "eat a tire"); }); - + it("should be able to call a method on the derived object", function() { - expect(this.gonzo.doTrick()).toEqual(FILL_ME_IN); + expect(this.gonzo.doTrick()).toEqual('eat a tire'); }); - + it("should be able to call a method on the base object", function() { - expect(this.gonzo.answerNanny()).toEqual(FILL_ME_IN); + expect(this.gonzo.answerNanny()).toEqual("Everything's cool!"); }); it("should set constructor parameters on the base object", function() { - expect(this.gonzo.age).toEqual(FILL_ME_IN); - expect(this.gonzo.hobby).toEqual(FILL_ME_IN); + expect(this.gonzo.age).toEqual(3); + expect(this.gonzo.hobby).toEqual('daredevel performer'); }); - + it("should set constructor parameters on the derived object", function() { - expect(this.gonzo.trick).toEqual(FILL_ME_IN); + expect(this.gonzo.trick).toEqual('eat a tire'); }); }); diff --git a/koans/AboutMutability.js b/koans/AboutMutability.js index 1e4511758..41fe2c891 100644 --- a/koans/AboutMutability.js +++ b/koans/AboutMutability.js @@ -3,20 +3,20 @@ describe("About Mutability", function() { it("should expect object properties to be public and mutable", function () { var aPerson = {firstname: "John", lastname: "Smith" }; aPerson.firstname = "Alan"; - - expect(aPerson.firstname).toBe(FILL_ME_IN); + + expect(aPerson.firstname).toBe('Alan'); }); it("should understand that constructed properties are public and mutable", function () { function Person(firstname, lastname) { this.firstname = firstname; - this.lastname = lastname; + this.lastname = lastname; } var aPerson = new Person ("John", "Smith"); aPerson.firstname = "Alan"; - - expect(aPerson.firstname).toBe(FILL_ME_IN); + + expect(aPerson.firstname).toBe('Alan'); }); it("should expect prototype properties to be public and mutable", function () { @@ -25,44 +25,44 @@ describe("About Mutability", function() { this.firstname = firstname; this.lastname = lastname; } - Person.prototype.getFullName = function () { + Person.prototype.getFullName = function() { return this.firstname + " " + this.lastname; }; - + var aPerson = new Person ("John", "Smith"); - expect(aPerson.getFullName()).toBe(FILL_ME_IN); - - aPerson.getFullName = function () { + expect(aPerson.getFullName()).toBe('John Smith'); + + aPerson.getFullName = function() { return this.lastname + ", " + this.firstname; }; - - expect(aPerson.getFullName()).toBe(FILL_ME_IN); + + expect(aPerson.getFullName()).toBe('Smith, John'); }); it("should know that variables inside a constructor and constructor args are private", function () { function Person(firstname, lastname) { var fullName = firstname + " " + lastname; - - this.getFirstName = function () { return firstname; }; - this.getLastName = function () { return lastname; }; - this.getFullName = function () { return fullName; }; + + this.getFirstName = function() { return firstname; }; + this.getLastName = function() { return lastname; }; + this.getFullName = function() { return fullName; }; } var aPerson = new Person ("John", "Smith"); aPerson.firstname = "Penny"; - aPerson.lastname = "Andrews"; - aPerson.fullName = "Penny Andrews"; - - expect(aPerson.getFirstName()).toBe(FILL_ME_IN); - expect(aPerson.getLastName()).toBe(FILL_ME_IN); - expect(aPerson.getFullName()).toBe(FILL_ME_IN); + aPerson.lastname = "Andrews"; + aPerson.fullName = "Penny Andrews"; - aPerson.getFullName = function () { + expect(aPerson.getFirstName()).toBe('John'); + expect(aPerson.getLastName()).toBe('Smith'); + expect(aPerson.getFullName()).toBe('John Smith'); + + aPerson.getFullName = function() { return aPerson.lastname + ", " + aPerson.firstname; }; - - expect(aPerson.getFullName()).toBe(FILL_ME_IN); + + expect(aPerson.getFullName()).toBe('Andrews, Penny'); }); }); diff --git a/koans/AboutObjects.js b/koans/AboutObjects.js index 374944e80..fd94f8724 100644 --- a/koans/AboutObjects.js +++ b/koans/AboutObjects.js @@ -1,92 +1,90 @@ -describe("About Objects", function () { +describe("About Objects", function() { - describe("Properties", function () { + describe("Properties", function() { var meglomaniac; - beforeEach(function () { + beforeEach(function() { meglomaniac = { mastermind: "Joker", henchwoman: "Harley" }; }); - it("should confirm objects are collections of properties", function () { - expect(meglomaniac.mastermind).toBe(FILL_ME_IN); - }); + it("should confirm objects are collections of properties", function() { + expect(meglomaniac.mastermind).toBe('Joker'); + }); - it("should confirm that properties are case sensitive", function () { - expect(meglomaniac.henchwoman).toBe(FILL_ME_IN); - expect(meglomaniac.henchWoman).toBe(FILL_ME_IN); + it("should confirm that properties are case sensitive", function() { + expect(meglomaniac.henchwoman).toBe('Harley'); + expect(meglomaniac.henchWoman).toBe('Harley'); }); }); - - it("should know properties that are functions act like methods", function () { - var meglomaniac = { - mastermind : "Brain", + + it("should know properties that are functions act like methods", function() { + var meglomaniac = { + mastermind : "Brain", henchman: "Pinky", - battleCry: function (noOfBrains) { + battleCry: function(noOfBrains) { return "They are " + this.henchman + " and the" + Array(noOfBrains + 1).join(" " + this.mastermind); } }; - + var battleCry = meglomaniac.battleCry(4); - expect(FILL_ME_IN).toMatch(battleCry); + expect('They are Pinky and the Brain Brain Brain Brain').toMatch(battleCry); }); it("should confirm that when a function is attached to an object, 'this' refers to the object", function () { - var currentDate = new Date() + var currentDate = new Date(); var currentYear = (currentDate.getFullYear()); - var meglomaniac = { - mastermind: "James Wood", + var meglomaniac = { + mastermind: "James Wood", henchman: "Adam West", birthYear: 1970, - calculateAge: function () { - return currentYear - this.birthYear; + calculateAge: function() { + return currentYear - this.birthYear; } }; - - expect(currentYear).toBe(FILL_ME_IN); - expect(meglomaniac.calculateAge()).toBe(FILL_ME_IN); + + expect(currentYear).toBe(2018); + expect(meglomaniac.calculateAge()).toBe(48); }); - describe("'in' keyword", function () { + describe("'in' keyword", function() { var meglomaniac; - beforeEach(function () { - meglomaniac = { - mastermind: "The Monarch", + beforeEach(function() { + meglomaniac = { + mastermind: "The Monarch", henchwoman: "Dr Girlfriend", theBomb: true }; }); - it("should have the bomb", function () { - + it("should have the bomb", function() { var hasBomb = "theBomb" in meglomaniac; - - expect(hasBomb).toBe(FILL_ME_IN); - }); - it("should not have the detonator however", function () { + expect(hasBomb).toBe(true); + }); + it("should not have the detonator however", function() { var hasDetonator = "theDetonator" in meglomaniac; - - expect(hasDetonator).toBe(FILL_ME_IN); - }); + + expect(hasDetonator).toBe(false); + }); }); - it("should know that properties can be added and deleted", function () { + it("should know that properties can be added and deleted", function() { var meglomaniac = { mastermind : "Agent Smith", henchman: "Agent Smith" }; - expect("secretary" in meglomaniac).toBe(FILL_ME_IN); + expect("secretary" in meglomaniac).toBe(false); meglomaniac.secretary = "Agent Smith"; - expect("secretary" in meglomaniac).toBe(FILL_ME_IN); - + expect("secretary" in meglomaniac).toBe(true); + delete meglomaniac.henchman; - expect("henchman" in meglomaniac).toBe(FILL_ME_IN); + expect("henchman" in meglomaniac).toBe(false); }); - it("should use prototype to add to all objects", function () { + it("should use prototype to add to all objects", function() { function Circle(radius) { this.radius = radius; @@ -95,15 +93,15 @@ describe("About Objects", function () { var simpleCircle = new Circle(10); var colouredCircle = new Circle(5); colouredCircle.colour = "red"; - - expect(simpleCircle.colour).toBe(FILL_ME_IN); - expect(colouredCircle.colour).toBe(FILL_ME_IN); - - Circle.prototype.describe = function () { + + expect(simpleCircle.colour).toBe(undefined); + expect(colouredCircle.colour).toBe('red'); + + Circle.prototype.describe = function() { return "This circle has a radius of: " + this.radius; }; - - expect(simpleCircle.describe()).toBe(FILL_ME_IN); - expect(colouredCircle.describe()).toBe(FILL_ME_IN); + + expect(simpleCircle.describe()).toBe('This circle has a radius of: 10'; + expect(colouredCircle.describe()).toBe('This circle has a radius of: 5'); }); });