various chapters: updating code style for consistency

Author: getify

ch1.md

@@ -29,15 +29,15 @@ outputMsg();             // The magic number is: 42
 // ***************
 
 function calculateMagicNumber() {
-	for (var i = 0; i < faves.length; i++) {
-		magicNumber = magicNumber + faves[i];
+	for (let fave of faves) {
+		magicNumber = magicNumber + fave;
 	}
 }
 
 function pickFavoriteNumbers() {
-	for (var i = 0; i < numbers.length; i++) {
-		if (numbers[i] >= 10 && numbers[i] <= 20) {
-			faves.push( numbers[i] );
+	for (let num of numbers) {
+		if (num >= 10 && num <= 20) {
+			faves.push( num );
 		}
 	}
 }

ch2.md

@@ -534,8 +534,8 @@ Consider:
 
 ```js
 function forEach(list,fn) {
-	for (let i = 0; i < list.length; i++) {
-		fn( list[i] );
+	for (let v of list) {
+		fn( v );
 	}
 }
 
@@ -775,9 +775,8 @@ function findPropIn(propName,obj) {
 		return obj[propName];
 	}
 	else {
-		let props = Object.keys( obj );
-		for (let i = 0; i < props.length; i++) {
-			let ret = findPropIn( propName, obj[props[i]] );
+		for (let prop of Object.keys( obj )) {
+			let ret = findPropIn( propName, obj[prop] );
 			if (ret !== undefined) {
 				return ret;
 			}

ch3.md

@@ -284,7 +284,7 @@ function partial(fn,...presetArgs) {
 
 // or the ES6 => arrow form
 var partial =
-	(fn, ...presetArgs) =>
+	(fn,...presetArgs) =>
 		(...laterArgs) =>
 			fn( ...presetArgs, ...laterArgs );
 ```
@@ -547,7 +547,7 @@ function curry(fn,arity = fn.length) {
 
 // or the ES6 => arrow form
 var curry =
-	(fn, arity = fn.length, nextCurried) =>
+	(fn,arity = fn.length,nextCurried) =>
 		(nextCurried = prevArgs =>
 			nextArg => {
 				var args = [ ...prevArgs, nextArg ];
@@ -601,13 +601,13 @@ var adder = curry( add );
 // [4,5,6,7,8]
 ```
 
-How about another numbers example, this time adding a list of them together:
+Let's look at another numbers example, this time adding a list of them together:
 
 ```js
-function sum(...args) {
+function sum(...nums) {
 	var total = 0;
-	for (let i = 0; i < args.length; i++) {
-		total += args[i];
+	for (let num of nums) {
+		total += num;
 	}
 	return total;
 }
@@ -773,8 +773,8 @@ function uncurry(fn) {
 	return function uncurried(...args){
 		var ret = fn;
 
-		for (let i = 0; i < args.length; i++) {
-			ret = ret( args[i] );
+		for (let arg of args) {
+			ret = ret( arg );
 		}
 
 		return ret;
@@ -787,8 +787,8 @@ var uncurry =
 		(...args) => {
 			var ret = fn;
 
-			for (let i = 0; i < args.length; i++) {
-				ret = ret( args[i] );
+			for (let arg of args) {
+				ret = ret( arg );
 			}
 
 			return ret;
@@ -798,10 +798,10 @@ var uncurry =
 **Warning:** Don't just assume that `uncurry(curry(f))` has the same behavior as `f`. In some libs the uncurrying would result in a function like the original, but not all of them; certainly our example here does not. The uncurried function acts (mostly) the same as the original function if you pass as many arguments to it as the original function expected. However, if you pass fewer arguments, you still get back a partially curried function waiting for more arguments; this quirk is illustrated in the next snippet.
 
 ```js
-function sum(...args) {
+function sum(...nums) {
 	var sum = 0;
-	for (let i = 0; i < args.length; i++) {
-		sum += args[i];
+	for (let num of nums) {
+		sum += num;
 	}
 	return sum;
 }

ch4.md

@@ -50,10 +50,10 @@ function words(str) {
 function unique(list) {
 	var uniqList = [];
 
-	for (let i = 0; i < list.length; i++) {
+	for (let v of list) {
 		// value not yet in the new list?
-		if (uniqList.indexOf( list[i] ) === -1 ) {
-			uniqList.push( list[i] );
+		if (uniqList.indexOf( v ) === -1 ) {
+			uniqList.push( v );
 		}
 	}
 
@@ -236,16 +236,16 @@ var compose =
 Now let's look at an example of composing more than two functions. Recalling our `uniqueWords(..)` composition example, let's add a `skipShortWords(..)` to the mix:
 
 ```js
-function skipShortWords(list) {
-	var filteredList = [];
+function skipShortWords(words) {
+	var filteredWords = [];
 
-	for (let i = 0; i < list.length; i++) {
-		if (list[i].length > 4) {
-			filteredList.push( list[i] );
+	for (let word of words) {
+		if (word.length > 4) {
+			filteredWords.push( word );
 		}
 	}
 
-	return filteredList;
+	return filteredWords;
 }
 ```
 

ch5.md

@@ -201,10 +201,10 @@ function fetchUserData(userId) {
 
 function fetchOrders(userId) {
 	ajax( "http://some.api/orders/" + userId, function onOrders(orders){
-		for (let i = 0; i < orders.length; i++) {
+		for (let order of orders) {
 			// keep a reference to latest order for each user
-			users[userId].latestOrder = orders[i];
-			userOrders[orders[i].orderId] = orders[i];
+			users[userId].latestOrder = order;
+			userOrders[orders[i].orderId] = order;
 		}
 	} );
 }
@@ -429,12 +429,12 @@ All the inputs (`x` and `y`) and outputs (`return ..`) are direct; there are no
 However, not all pure functions are idempotent in the mathematical sense, because they don't have to return a value that would be suitable for feeding back in as their own input. Consider:
 
 ```js
-function calculateAverage(list) {
+function calculateAverage(nums) {
 	var sum = 0;
-	for (let i = 0; i < list.length; i++) {
-		sum += list[i];
+	for (let num of nums) {
+		sum += num;
 	}
-	return sum / list.length;
+	return sum / nums.length;
 }
 
 calculateAverage( [1,2,4,7,11,16,22] );			// 9
@@ -634,31 +634,31 @@ Referential transparency is the assertion that a function call could be replaced
 From the perspective of referential transparency, both of these programs have identical behavior as they are built with pure functions:
 
 ```js
-function calculateAverage(list) {
+function calculateAverage(nums) {
 	var sum = 0;
-	for (let i = 0; i < list.length; i++) {
-		sum += list[i];
+	for (let num of nums) {
+		sum += num;
 	}
-	return sum / list.length;
+	return sum / nums.length;
 }
 
-var nums = [1,2,4,7,11,16,22];
+var numbers = [1,2,4,7,11,16,22];
 
-var avg = calculateAverage( nums );
+var avg = calculateAverage( numbers );
 
 console.log( "The average is:", avg );		// The average is: 9
 ```
 
 ```js
-function calculateAverage(list) {
+function calculateAverage(nums) {
 	var sum = 0;
-	for (let i = 0; i < list.length; i++) {
-		sum += list[i];
+	for (let num of nums) {
+		sum += num;
 	}
-	return sum / list.length;
+	return sum / nums.length;
 }
 
-var nums = [1,2,4,7,11,16,22];
+var numbers = [1,2,4,7,11,16,22];
 
 var avg = 9;
 
@@ -688,17 +688,18 @@ What about a function that has a side effect, but this side effect isn't ever ob
 Here's one:
 
 ```js
-function calculateAverage(list) {
+function calculateAverage(nums) {
 	sum = 0;
-	for (let i = 0; i < list.length; i++) {
-		sum += list[i];
+	for (let num of nums) {
+		sum += num;
 	}
-	return sum / list.length;
+	return sum / nums.length;
 }
 
-var sum, nums = [1,2,4,7,11,16,22];
+var sum;
+var numbers = [1,2,4,7,11,16,22];
 
-var avg = calculateAverage( nums );
+var avg = calculateAverage( numbers );
 ```
 
 Did you spot it?

ch8.md

@@ -165,8 +165,8 @@ Simple iterative algorithms can trivially be expressed as recursion:
 
 ```js
 function sum(total,...nums) {
-	for (let i = 0; i < nums.length; i++) {
-		total = total + nums[i];
+	for (let num of nums) {
+		total = total + num;
 	}
 
 	return total;
@@ -192,16 +192,16 @@ Recursion is declarative for algorithms in the same sense that **Σ** is declara
 
 ```js
 function maxEven(...nums) {
-	var num = -Infinity;
+	var maxNum = -Infinity;
 
-	for (let i = 0; i < nums.length; i++) {
-		if (nums[i] % 2 == 0 && nums[i] > num) {
-			num = nums[i];
+	for (let num of nums) {
+		if (num % 2 == 0 && num > maxNum) {
+			maxNum = num;
 		}
 	}
 
 	if (num !== -Infinity) {
-		return num;
+		return maxNum;
 	}
 }
 ```

ch9.md

@@ -72,9 +72,9 @@ To implement `map(..)`:
 function map(mapperFn,arr) {
 	var newList = [];
 
-	for (let idx = 0; idx < arr.length; idx++) {
+	for (let [idx,v] of arr.entries()) {
 		newList.push(
-			mapperFn( arr[idx], idx, arr )
+			mapperFn( v, idx, arr )
 		);
 	}
 
@@ -241,9 +241,9 @@ To implement `filter(..)`:
 function filter(predicateFn,arr) {
 	var newList = [];
 
-	for (let idx = 0; idx < arr.length; idx++) {
-		if (predicateFn( arr[idx], idx, arr )) {
-			newList.push( arr[idx] );
+	for (let [idx,v] of arr.entries()) {
+		if (predicateFn( v, idx, arr )) {
+			newList.push( v );
 		}
 	}