JavaScript编程精解（第三版）第四章习题解答

第一题：求一个范围内数的总和

这题很简单，定义两个函数即可实现。

let range = (start, end, step = 1) => {
  let arr = [];
  for(let i = start; i <= end; i += step) arr.push(i);
  return arr;
};

let sum = arr => {
  let res = 0;
  for(let e of arr) res += e;
  return res;
}

console.log(sum(range(1, 10))) // ->55

第二题：反转数组

也非常简单，首先我们实现非原地翻转的函数，借助一个新数组：

let reverseArray = arr => {
  let newArr = [];
  for(int i = arr.length - 1; i >= 0; i--) new_arr.push(arr[i]);
  return newArr;
};

然后我们实现一个原地翻转，只需要将第 i 位上的元素与第 n - i -1位上的元素交换即可。

let reverseArrayInPlace = arr => {
  let n = arr.length;
  for(let i = 0; i < n / 2; i++) {
    [arr[i], arr[n - i - 1]] = [arr[n - i - 1], arr[i]]; // 解构语法，不带上括号就无法成功交换
  }
};

第三题：一个列表

我们可以利用迭代的方式来实现这个效果，首先将第一个元素插入到数组中，然后从第二个元素起开始遍历，每个元素都插入到上一个元素的 rest 域中即可。

首先我们实现一下 arrayToList函数：

let arrayToList = arr => {
  	if(arr.length == 0) return list;
  	let list = {value: arr[0], rest: null};
  	let tail = list;
  	for(let i = 1; i < arr.length; i++) {
     	tail.rest = {value: arr[i], rest: null};
      	tail = tail.rest;
    }
  	return list;
};

然后我们实现一下 listToArray函数：

let listToArray = list => {
  let arr = [];
  for(let node = list; node; node = node.rest) {
    arr.push(node.value);
  }
  return arr;
};

接着实现一下 prepend函数：

let prepend = (value, list) => {
 	return {value: value, rest: list};
};

最后我们分别实现一下迭代版本和递归版本的 nth函数：

迭代版本：

let nth = (list, num) => {
  	if(list.length == 0 || num < 0) return undefined;
  	let node = list;
  	while(num > 0 && node) {
      num--;
      node = node.rest;
    }
  	if(num == 0) return node.value;
  	return undefined;
};

递归版本：

let nth = (list, num) => {
  	if(list.length == 0 || num < 0) return undefined;
	if(num == 0) return list.value;
  	return nth(list.rest, num - 1);
};

第四题：深度比较

let deepEqual = (obj1, obj2) => {
  if(obj1=== obj2) return true; // 指向同一个内存
   if((typeof obj1 == "object" && obj1 != null) &&
       typeof obj2 == "object" && obj2 != null) { // 判断两个变量都是对象类型并且均不为空
    //如果属性个数不同两个变量肯定不同
    if(Object.keys(obj1).length != Object.keys(obj2).length) return false;
    
      for(let prop in obj1) { // 遍历对象判断是否相等
         if(obj2.hasOwnProperty(prop)) {
           // 如果ojb2中含有ojb1的属性，则进行递归（既可以处理属性是对象的嵌套情况，又可以处理单个情况）
           if(!deepEqual(obj1[prop], obj2[prop])) return false;
         } else return false;
      }
    	return true;
  }
  return false;
};

写法二：

function deepEqual(a, b) {
  if (a === b) return true;
  
  if (a == null || typeof a != "object" ||
      b == null || typeof b != "object") return false;

  let keysA = Object.keys(a), keysB = Object.keys(b);

  if (keysA.length != keysB.length) return false;

  for (let key of keysA) {
    if (!keysB.includes(key) || !deepEqual(a[key], b[key])) return false;
  }

  return true;
}