要点索引：

1、补：js字符串的表达方式有三种： "" 和 '' 没什么区别，唯一区别在于 "" 中写 "要转义字符，在 '' 中写 ' 要转义字符。最后一种是 `` ，允许 'xx = ${算式}' 的简写方式。

2、两种主要的访问对象属性的方式 —— 点号与 [ ]

[ ] 会获取 [ ] 中的计算后字符串，点号则不会。

必须用 [ ] 的场景是访问数组属性 x[1]， 因为点号后不能跟数字。

3、js数组自带push和pop方法。

队列也可以很容易实现：

  1. let todoList = [];
  2. function remember(task) {
  3.   todoList.push(task);
  4. }
  5. function getTask() {
  6.   return todoList.shift();
  7. }
  8. // 紧急事件插入到队列前面
  9. function rememberUrgently(task) {
  10.   todoList.unshift(task);
  11. }

4、对象的属性中，非有效引用名（例如包含空格↓）必须用字符串形式表达：

  1. let descriptions = {
  2.   work: "Went to work",
  3.   "touched tree": "Touched a tree"
  4. };

且必须要用 [ ] 访问该属性：

  1. descriptions["touched tree"]

5、js对象允许动态添加属性：

  1. descriptions["another property"] = "new one";

如果已经存在就替换。点号也是可以的，但 [ ] 比较通用。

6、动态删除属性：

  1. /*
  2.  * 可以把对象想象成一只章鱼，对象的属性想象成带着便签
  3.  * 的章鱼触手，数组也是一种对象，typeof [];的结果是object
  4.  * 所以数组是一种触手上的便签全为顺序数字的章鱼。
  5.  */
  6. let octopuse = {
  7.     tentacleA: 1,
  8.     tentacleB: 2,
  9.     tentacleC: 3
  10. };
  11.  
  12. console.log(octopuse.tentacleA);
  13. // → 1
  14. delete octopuse.tentacleA;
  15. console.log(octopuse.tentacleA);
  16. // → undefined
  17. console.log('tentacleA' in octopuse);
  18. // → false

用in来判断属性是否存在才是准确的，因为值本身可能为undefined

注意，delete删除是有后遗症的！并不会删除干净（会留引用）。所以能用filter尽量不用delete

【PS. in和includes貌似可以互相替换？】

7、列出对象的所有属性名：

  1. console.log(Object.keys(octopuse));
  2. // → ["tentacleB", "tentacleC"]

8、Object.assign：

  1. let objectA = {a: 1, b: 2};
  2. Object.assign(objectA, {b: 3, c: 4});
  3. console.log(objectA);
  4. // → {a: 1, b: 3, c: 4}

9、多个引用可以指向同一个对象，obj1==obj2比较的是引用的值（只有指向同一个对象才返回true），而不是对象的内容。

const obj只是引用的值不变，不能保证所指向对象的内容不变。

（上述两点都可以类比Java）

10、直接传入绑定（键值对）：

  1. let journal = [];
  2.  
  3. function addEntry(events, squirrel) {
  4.   journal.push({events, squirrel});
  5. }

11、重写书上的示例（探究xxx变成松鼠的原因）：

  1. /**
  2.  * getPhi返回变成松鼠和事件的
  3.  * 相关性，返回的值为-1~1，-1表示
  4.  * 负相关，1表示正相关，0表示毫无关系。
  5.  * table表示一个二维表，用于统
  6.  * 计下面四种事件发生的次数：
  7.  * 1、不变松鼠，事件没发生00=0，
  8.  * 2、不变松鼠，事件发生01=1，
  9.  * 3、变成松鼠，事件没发生10=2，
  10.  * 4、变成松鼠，事件发生11=3
  11.  * 测试：
  12.  * console.log(getPhi([76, 9, 4, 1]));
  13.  * → 0.06859943405700354
  14.  */
  15. const getPhi = (table) => {
  16.   return (table[3] * table[0] - table[2] * table[1]) /
  17.     Math.sqrt((table[2] + table[3]) *
  18.               (table[0] + table[1]) *
  19.               (table[1] + table[3]) *
  20.               (table[0] + table[2]));
  21. };
  22.  
  23. /**
  24.  * 获取特定事件对应的表格，测试：
  25.  * console.log(getTable(JOURNAL, "pizza"));
  26.  * → [76, 9, 4, 1]
  27.  */
  28. const getTable = (JOURNAL, specificEvent) => {
  29.     let result = [0, 0, 0, 0];
  30.     for (let someday of JOURNAL) {
  31.         let tableIndex = 0;
  32.         if (someday.squirrel) tableIndex += 2;
  33.         if (someday.events.includes(specificEvent)) tableIndex += 1;
  34.         result[tableIndex]++;
  35.     }
  36.     return result;
  37. };
  38.  
  39. /**
  40.  * 返回包括日志所记录的所有事件的字符串数组
  41.  */
  42. const getAllEvents = (JOURNAL) => {
  43.     let result = [];
  44.     for (let x of JOURNAL) {
  45.         for (let theEvent of x.events) {
  46.             if (!result.includes(theEvent)) {
  47.                 result.push(theEvent);
  48.             }
  49.         }
  50.     }
  51.     return result;
  52. };
  53.  
  54. const main = () => {
  55.     let allEvents = getAllEvents(JOURNAL);
  56.     for (let specificEvent of allEvents) {
  57.         let table = getTable(JOURNAL, specificEvent);
  58.         console.log(specificEvent + ":", getPhi(table));
  59.     }
  60. };

数据：

  1. let JOURNAL = [{
  2.         "events": ["carrot", "exercise", "weekend"],
  3.         "squirrel": false
  4.     },
  5.     {
  6.         "events": ["bread", "pudding", "brushed teeth", "weekend", "touched tree"],
  7.         "squirrel": false
  8.     },
  9.     {
  10.         "events": ["carrot", "nachos", "brushed teeth", "cycling", "weekend"],
  11.         "squirrel": false
  12.     },
  13.     {
  14.         "events": ["brussel sprouts", "ice cream", "brushed teeth", "computer", "weekend"],
  15.         "squirrel": false
  16.     },
  17.     {
  18.         "events": ["potatoes", "candy", "brushed teeth", "exercise", "weekend", "dentist"],
  19.         "squirrel": false
  20.     },
  21.     {
  22.         "events": ["brussel sprouts", "pudding", "brushed teeth", "running", "weekend"],
  23.         "squirrel": false
  24.     },
  25.     {
  26.         "events": ["pizza", "brushed teeth", "computer", "work", "touched tree"],
  27.         "squirrel": false
  28.     },
  29.     {
  30.         "events": ["bread", "beer", "brushed teeth", "cycling", "work"],
  31.         "squirrel": false
  32.     },
  33.     {
  34.         "events": ["cauliflower", "brushed teeth", "work"],
  35.         "squirrel": false
  36.     },
  37.     {
  38.         "events": ["pizza", "brushed teeth", "cycling", "work"],
  39.         "squirrel": false
  40.     },
  41.     {
  42.         "events": ["lasagna", "nachos", "brushed teeth", "work"],
  43.         "squirrel": false
  44.     },
  45.     {
  46.         "events": ["brushed teeth", "weekend", "touched tree"],
  47.         "squirrel": false
  48.     },
  49.     {
  50.         "events": ["lettuce", "brushed teeth", "television", "weekend"],
  51.         "squirrel": false
  52.     },
  53.     {
  54.         "events": ["spaghetti", "brushed teeth", "work"],
  55.         "squirrel": false
  56.     },
  57.     {
  58.         "events": ["brushed teeth", "computer", "work"],
  59.         "squirrel": false
  60.     },
  61.     {
  62.         "events": ["lettuce", "nachos", "brushed teeth", "work"],
  63.         "squirrel": false
  64.     },
  65.     {
  66.         "events": ["carrot", "brushed teeth", "running", "work"],
  67.         "squirrel": false
  68.     },
  69.     {
  70.         "events": ["brushed teeth", "work"],
  71.         "squirrel": false
  72.     },
  73.     {
  74.         "events": ["cauliflower", "reading", "weekend"],
  75.         "squirrel": false
  76.     },
  77.     {
  78.         "events": ["bread", "brushed teeth", "weekend"],
  79.         "squirrel": false
  80.     },
  81.     {
  82.         "events": ["lasagna", "brushed teeth", "exercise", "work"],
  83.         "squirrel": false
  84.     },
  85.     {
  86.         "events": ["spaghetti", "brushed teeth", "reading", "work"],
  87.         "squirrel": false
  88.     },
  89.     {
  90.         "events": ["carrot", "ice cream", "brushed teeth", "television", "work"],
  91.         "squirrel": false
  92.     },
  93.     {
  94.         "events": ["spaghetti", "nachos", "work"],
  95.         "squirrel": false
  96.     },
  97.     {
  98.         "events": ["cauliflower", "ice cream", "brushed teeth", "cycling", "work"],
  99.         "squirrel": false
  100.     },
  101.     {
  102.         "events": ["spaghetti", "peanuts", "computer", "weekend"],
  103.         "squirrel": true
  104.     },
  105.     {
  106.         "events": ["potatoes", "ice cream", "brushed teeth", "computer", "weekend"],
  107.         "squirrel": false
  108.     },
  109.     {
  110.         "events": ["potatoes", "ice cream", "brushed teeth", "work"],
  111.         "squirrel": false
  112.     },
  113.     {
  114.         "events": ["peanuts", "brushed teeth", "running", "work"],
  115.         "squirrel": false
  116.     },
  117.     {
  118.         "events": ["potatoes", "exercise", "work"],
  119.         "squirrel": false
  120.     },
  121.     {
  122.         "events": ["pizza", "ice cream", "computer", "work"],
  123.         "squirrel": false
  124.     },
  125.     {
  126.         "events": ["lasagna", "ice cream", "work"],
  127.         "squirrel": false
  128.     },
  129.     {
  130.         "events": ["cauliflower", "candy", "reading", "weekend"],
  131.         "squirrel": false
  132.     },
  133.     {
  134.         "events": ["lasagna", "nachos", "brushed teeth", "running", "weekend"],
  135.         "squirrel": false
  136.     },
  137.     {
  138.         "events": ["potatoes", "brushed teeth", "work"],
  139.         "squirrel": false
  140.     },
  141.     {
  142.         "events": ["carrot", "work"],
  143.         "squirrel": false
  144.     },
  145.     {
  146.         "events": ["pizza", "beer", "work", "dentist"],
  147.         "squirrel": false
  148.     },
  149.     {
  150.         "events": ["lasagna", "pudding", "cycling", "work"],
  151.         "squirrel": false
  152.     },
  153.     {
  154.         "events": ["spaghetti", "brushed teeth", "reading", "work"],
  155.         "squirrel": false
  156.     },
  157.     {
  158.         "events": ["spaghetti", "pudding", "television", "weekend"],
  159.         "squirrel": false
  160.     },
  161.     {
  162.         "events": ["bread", "brushed teeth", "exercise", "weekend"],
  163.         "squirrel": false
  164.     },
  165.     {
  166.         "events": ["lasagna", "peanuts", "work"],
  167.         "squirrel": true
  168.     },
  169.     {
  170.         "events": ["pizza", "work"],
  171.         "squirrel": false
  172.     },
  173.     {
  174.         "events": ["potatoes", "exercise", "work"],
  175.         "squirrel": false
  176.     },
  177.     {
  178.         "events": ["brushed teeth", "exercise", "work"],
  179.         "squirrel": false
  180.     },
  181.     {
  182.         "events": ["spaghetti", "brushed teeth", "television", "work"],
  183.         "squirrel": false
  184.     },
  185.     {
  186.         "events": ["pizza", "cycling", "weekend"],
  187.         "squirrel": false
  188.     },
  189.     {
  190.         "events": ["carrot", "brushed teeth", "weekend"],
  191.         "squirrel": false
  192.     },
  193.     {
  194.         "events": ["carrot", "beer", "brushed teeth", "work"],
  195.         "squirrel": false
  196.     },
  197.     {
  198.         "events": ["pizza", "peanuts", "candy", "work"],
  199.         "squirrel": true
  200.     },
  201.     {
  202.         "events": ["carrot", "peanuts", "brushed teeth", "reading", "work"],
  203.         "squirrel": false
  204.     },
  205.     {
  206.         "events": ["potatoes", "peanuts", "brushed teeth", "work"],
  207.         "squirrel": false
  208.     },
  209.     {
  210.         "events": ["carrot", "nachos", "brushed teeth", "exercise", "work"],
  211.         "squirrel": false
  212.     },
  213.     {
  214.         "events": ["pizza", "peanuts", "brushed teeth", "television", "weekend"],
  215.         "squirrel": false
  216.     },
  217.     {
  218.         "events": ["lasagna", "brushed teeth", "cycling", "weekend"],
  219.         "squirrel": false
  220.     },
  221.     {
  222.         "events": ["cauliflower", "peanuts", "brushed teeth", "computer", "work", "touched tree"],
  223.         "squirrel": false
  224.     },
  225.     {
  226.         "events": ["lettuce", "brushed teeth", "television", "work"],
  227.         "squirrel": false
  228.     },
  229.     {
  230.         "events": ["potatoes", "brushed teeth", "computer", "work"],
  231.         "squirrel": false
  232.     },
  233.     {
  234.         "events": ["bread", "candy", "work"],
  235.         "squirrel": false
  236.     },
  237.     {
  238.         "events": ["potatoes", "nachos", "work"],
  239.         "squirrel": false
  240.     },
  241.     {
  242.         "events": ["carrot", "pudding", "brushed teeth", "weekend"],
  243.         "squirrel": false
  244.     },
  245.     {
  246.         "events": ["carrot", "brushed teeth", "exercise", "weekend", "touched tree"],
  247.         "squirrel": false
  248.     },
  249.     {
  250.         "events": ["brussel sprouts", "running", "work"],
  251.         "squirrel": false
  252.     },
  253.     {
  254.         "events": ["brushed teeth", "work"],
  255.         "squirrel": false
  256.     },
  257.     {
  258.         "events": ["lettuce", "brushed teeth", "running", "work"],
  259.         "squirrel": false
  260.     },
  261.     {
  262.         "events": ["candy", "brushed teeth", "work"],
  263.         "squirrel": false
  264.     },
  265.     {
  266.         "events": ["brussel sprouts", "brushed teeth", "computer", "work"],
  267.         "squirrel": false
  268.     },
  269.     {
  270.         "events": ["bread", "brushed teeth", "weekend"],
  271.         "squirrel": false
  272.     },
  273.     {
  274.         "events": ["cauliflower", "brushed teeth", "weekend"],
  275.         "squirrel": false
  276.     },
  277.     {
  278.         "events": ["spaghetti", "candy", "television", "work", "touched tree"],
  279.         "squirrel": false
  280.     },
  281.     {
  282.         "events": ["carrot", "pudding", "brushed teeth", "work"],
  283.         "squirrel": false
  284.     },
  285.     {
  286.         "events": ["lettuce", "brushed teeth", "work"],
  287.         "squirrel": false
  288.     },
  289.     {
  290.         "events": ["carrot", "ice cream", "brushed teeth", "cycling", "work"],
  291.         "squirrel": false
  292.     },
  293.     {
  294.         "events": ["pizza", "brushed teeth", "work"],
  295.         "squirrel": false
  296.     },
  297.     {
  298.         "events": ["spaghetti", "peanuts", "exercise", "weekend"],
  299.         "squirrel": true
  300.     },
  301.     {
  302.         "events": ["bread", "beer", "computer", "weekend", "touched tree"],
  303.         "squirrel": false
  304.     },
  305.     {
  306.         "events": ["brushed teeth", "running", "work"],
  307.         "squirrel": false
  308.     },
  309.     {
  310.         "events": ["lettuce", "peanuts", "brushed teeth", "work", "touched tree"],
  311.         "squirrel": false
  312.     },
  313.     {
  314.         "events": ["lasagna", "brushed teeth", "television", "work"],
  315.         "squirrel": false
  316.     },
  317.     {
  318.         "events": ["cauliflower", "brushed teeth", "running", "work"],
  319.         "squirrel": false
  320.     },
  321.     {
  322.         "events": ["carrot", "brushed teeth", "running", "work"],
  323.         "squirrel": false
  324.     },
  325.     {
  326.         "events": ["carrot", "reading", "weekend"],
  327.         "squirrel": false
  328.     },
  329.     {
  330.         "events": ["carrot", "peanuts", "reading", "weekend"],
  331.         "squirrel": true
  332.     },
  333.     {
  334.         "events": ["potatoes", "brushed teeth", "running", "work"],
  335.         "squirrel": false
  336.     },
  337.     {
  338.         "events": ["lasagna", "ice cream", "work", "touched tree"],
  339.         "squirrel": false
  340.     },
  341.     {
  342.         "events": ["cauliflower", "peanuts", "brushed teeth", "cycling", "work"],
  343.         "squirrel": false
  344.     },
  345.     {
  346.         "events": ["pizza", "brushed teeth", "running", "work"],
  347.         "squirrel": false
  348.     },
  349.     {
  350.         "events": ["lettuce", "brushed teeth", "work"],
  351.         "squirrel": false
  352.     },
  353.     {
  354.         "events": ["bread", "brushed teeth", "television", "weekend"],
  355.         "squirrel": false
  356.     },
  357.     {
  358.         "events": ["cauliflower", "peanuts", "brushed teeth", "weekend"],
  359.         "squirrel": false
  360.     }
  361. ];

12、重写getPhi

  1. function phi([n00, n01, n10, n11]) {
  2.   return (n11 * n00 - n10 * n01) /
  3.     Math.sqrt((n10 + n11) * (n00 + n01) *
  4.               (n01 + n11) * (n00 + n10));
  5. }

13、JSON是方便在网络上传输的数据，详情直接阅读百度百科。它的格式规定是非常严格的：JSON的属性必须由双引号包围，JSON中不能有注释 ...

  1. let obj = {
  2.     a: 123,
  3.     b: "456"
  4. };
  5.  
  6. console.log(obj);
  7. // → {a: 123, b: "456"}
  8.  
  9. let string = JSON.stringify(obj);
  10.  
  11. console.log(string);
  12. // → {"a":123,"b":"456"}
  13.  
  14. let obj2 = JSON.parse(string);
  15. console.log(obj2);
  16. // → {a: 123, b: "456"}
  17.  
  18. console.log(obj == obj2);
  19. // → false

PS. === 是精确比较，不会进行类型转换，== 会进行类型转换（例如 1 == '1' 是true），在类型确定相同的情况下可以用。

14、各种语言中的可变参数（java、python、c++、javascript）

15、More ...

常用数组方法

常用string方法

常用Math方法

大约在全文 2 /3 处

16、练习

① 实现range(a, b)，返回[a, ... , b]。

（省略sum）

  1. onst range = (start, end, step=1) => {
  2.     let result = [];
  3.     if (start <= end && step > 0) {
  4.         for (let i = start; i <= end; i+=step) {
  5.             result.push(i);
  6.         }
  7.     } else if (step < 0) {
  8.         for (let i = start; i >= end; i+=step) {
  9.             result.push(i);
  10.         }
  11.     }
  12.     return result;
  13. };
  14.  
  15. console.log(range(1, 10));
  16. console.log(range(5, 2, -1));
  17. console.log(range(5, 2, 1));
  18. // → [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  19. // → [5, 4, 3, 2]
  20. // → []

- - -- - - - - - -        -- -  -- -  - -- - - -          -- -  -- - - -- - - - - -- - - -- --

② 字符串倒序

  1. let x = ['A', 'b', 'C'];
  2. console.log(x.reverse());
  3. console.log(x);
  4. // → ["C", "b", "A"]
  5. // → ["C", "b", "A"]
  6.  
  7. const reverseArray = arr => {
  8.     let result = [];
  9.     for (let i = 0; i != arr.length; ++i) {
  10.         result.unshift(arr[i]); // 进队
  11.     }
  12.     return result;
  13. };
  14.  
  15. console.log(reverseArray(x));
  16. console.log(x);
  17. // → ["A", "b", "C"]
  18. // → ["C", "b", "A"]
  19.  
  20. const reverseArrayInPlace = arr => {
  21.     let start = 0;
  22.     let end = arr.length - 1;
  23.     while (start < end) {
  24.         let temp = arr[start];
  25.         arr[start++] = arr[end];
  26.         arr[end--] = temp;
  27.     }
  28. };
  29.  
  30. console.log(reverseArrayInPlace(x));
  31. console.log(x);
  32. // → undefined
  33. // → ["A", "b", "C"]

- - -- - - - - - -        -- -  -- -  - -- - - -          -- -  -- - - -- - - - - -- - - -- --

③ 单向链表

  1. const arrayToList = arr => {
  2.     // 空数组直接返回null
  3.     if(arr.length == 0) return null;
  4.  
  5.     let index = 0;
  6.     let result = {
  7.         value: arr[index++],
  8.         rest: null
  9.     };
  10.     // 数组元素数量为1在初始化后立刻返回结果
  11.     if(arr.length == 1) return result;
  12.  
  13.     // 数组元素数量大于1继续添加元素到list
  14.     let next = result;
  15.     while(index < arr.length) {
  16.         next = next.rest = {
  17.             value: arr[index],
  18.             rest: null
  19.         };
  20.         index++;
  21.     }
  22.     return result;
  23. };
  24.  
  25. console.log(arrayToList([10, 20, 30]));
  26. // → {value: 10, rest: {…}}
  27.  
  28. const listToArray = list => {
  29.     let result = [];
  30.  
  31.     while (list.rest != null) {
  32.         result.push(list.value);
  33.         list = list.rest;
  34.     }
  35.     result.push(list.value);
  36.  
  37.     return result;
  38. };
  39.  
  40. console.log(listToArray(arrayToList([10, 20, 30])));
  41. // → [10, 20, 30]
  42.  
  43. const prepend = (x, list) => {
  44.     let result = {
  45.         value: x,
  46.         rest: list
  47.     };
  48.     return result;
  49. };
  50.  
  51. console.log(prepend(10, prepend(20, null)));
  52. // → {value: 10, rest: {…}}
  53.  
  54. const nth = (list, x) => {
  55.     for (let i = 0; i < x; ++i) {
  56.         list = list.rest;
  57.     }
  58.     return list.value;
  59. };
  60.  
  61. console.log(nth(arrayToList([10, 20, 30]), 1));
  62. // → 20

递归版本nth：

  1. const nth = (list, x) => {
  2.     if (x == 0) return list.value;
  3.     return nth(list.rest, --x);
  4. };

课本解法（简洁了一倍。。）：

  1. function arrayToList(array) {
  2.   let list = null;
  3.   for (let i = array.length - 1; i >= 0; i--) {
  4.     list = {value: array[i], rest: list};
  5.   }
  6.   return list;
  7. }
  8.  
  9. function listToArray(list) {
  10.   let array = [];
  11.   for (let node = list; node; node = node.rest) {
  12.     array.push(node.value);
  13.   }
  14.   return array;
  15. }
  16.  
  17. function prepend(value, list) {
  18.   return {value, rest: list};
  19. }
  20.  
  21. function nth(list, n) {
  22.   if (!list) return undefined;
  23.   else if (n == 0) return list.value;
  24.   else return nth(list.rest, n - 1);
  25. }

- - -- - - - - - -        -- -  -- -  - -- - - -          -- -  -- - - -- - - - - -- - - -- --

④ 深度比较

  1. const deepEqual = (a, b) => {
  2.     let typeA = typeof a;
  3.     let typeB = typeof b;
  4.     // 类型不同直接返回false
  5.     if (typeA != typeB) return false;
  6.  
  7.     // 判断是不是可以直接比较的类型
  8.     let comparedDirectly = ["boolean", "number", "string"];
  9.     if (comparedDirectly.includes(typeA)) return a === b;
  10.  
  11.     // 先排除值为null的情况
  12.     if (a == null && b == null) return true;
  13.     if (a == null && b != null || a !=null && b == null) return false;
  14.     // 递归判断
  15.     if (typeA == "object") {
  16.         let keyA = Object.keys(a);
  17.         let keyB = Object.keys(b);
  18.         if (keyA.length != keyB.length) return false;
  19.         for (let k of keyA) {
  20.             if (keyB.includes(k)) {
  21.                 return deepEqual(a[k], b[k]);
  22.             } else {
  23.                 return false;
  24.             }
  25.         }
  26.     }
  27.  
  28.     // 其它情况一律返回未定义
  29.     return undefined;
  30. };
  31.  
  32. let obj = {here: {is: "an"}, object: 2};
  33. console.log(deepEqual(obj, obj));
  34. // → true
  35. console.log(deepEqual(obj, {here: 1, object: 2}));
  36. // → false
  37. console.log(deepEqual(obj, {here: {is: "an"}, object: 2}));
  38. // → true

课本解法：

  1. function deepEqual(a, b) {
  2.   if (a === b) return true;
  3.  
  4.   // null == null 的情况在 a === b 时已经过滤掉了。
  5.   if (a == null || typeof a != "object" ||
  6.       b == null || typeof b != "object") return false;
  7.  
  8.   let keysA = Object.keys(a), keysB = Object.keys(b);
  9.  
  10.   if (keysA.length != keysB.length) return false;
  11.  
  12.   for (let key of keysA) {
  13.     if (!keysB.includes(key) || !deepEqual(a[key], b[key])) return false;
  14.   }
  15.  
  16.   return true;
  17. }

Eloquent JavaScript #04# Objects and Arrays的更多相关文章

  1. Eloquent JavaScript #13# HTTP and Forms

    索引 Notes fetch form focus Disabled fields form’s elements property 阻止提交 快速插入单词 实时统计字数 监听checkbox和rad ...

  2. Objects、Arrays、Collectors、System工具类

    Objects类 定义 位于java.util包中,JDK1.7以后操作对象的类,对对象的空,对象是否相等进行判断. 常用方法 1.public static boolean equals(Objec ...

  3. Javascript笔记--Objects

     Javascript的简单数据类型包括: 数字,字符串,true/false,null 和undefined. 其他所有值都是对象. 数组是对象,方法也是对象.属性值是除开undefined值以外的 ...

  4. javascript . 04 匿名函数、递归、回调函数、对象、基于对象的javascript、状态和行为、New、This、构造函数／自定义对象、属性绑定、进制转换

    匿名函数:   没有名字的函数,函数整体加小括号不报错, 函数调用 : a:直接调用 (function (){函数体}) ( ) ; b:事件绑定 document.onlick = functio ...

  5. Eloquent JavaScript #12# Handling Events

    索引 Notes onclick removeEventListener Event objects stopPropagation event.target Default actions Key ...

  6. Eloquent JavaScript #11# The Document Object Model

    索引 Notes js与html DOM 在DOM树中移动 在DOM中寻找元素 改变Document 创建节点 html元素属性 布局 style CSS选择器 动画 Exercises Build ...

  7. Eloquent JavaScript #10# Modules

    索引 Notes 背景问题 模块Modules 软件包Packages 简易模块 Evaluating data as code CommonJS modules ECMAScript modules ...

  8. Eloquent JavaScript #05# higher-order functions

    索引 Notes 高阶函数 forEach filter map reduce some findIndex 重写课本示例代码 Excercises Flattening Your own loop ...

  9. Eloquent JavaScript #03# functions

    索引: let VS. var 定义函数的几种方式 more... 1.作者反复用的side effect side effect就是对世界造成的改变,例如说打印某些东西到屏幕,或者以某种方式改变机器 ...

随机推荐

  1. Devops路线

    自动化运维工具 Docker学习 .

  2. EditText的一些使用技巧

    1.让EditText不自动获取焦点 将EditText的某个父级控件设置成 android:focusable="true" android:focusableInTouchMo ...

  3. 118A

    #include <iostream> #include <cctype> #include <string> using namespace std; int m ...

  4. centos7部署fabric-ca错误解决

    1.fabric-ca 编译错误:ltdl.h: no such file 在fabric-ca目录中使用make编译时,会出现如下错误: 解决方案: 如果在ubunt操作系统中,只需安装:apt i ...

  5. Mac Maven配置

    Maven下载链接,解压到指定目录,我这里是 /Users/JYH/Desktop/Hadoop-2.7.2/apache-maven-3.3.9 打开终端,配置环境变量 输入命令 vi ~/.bas ...

  6. TextBox显示提示信息

    属性placeholder可以设置TextBox 提示信息如: <asp:TextBox ID ="txt1" runat ="server"  Tool ...

  7. 从零开始一起学习SLAM | 三维空间刚体的旋转

    刚体,顾名思义,是指本身不会在运动过程中产生形变的物体,如相机的运动就是刚体运动,运动过程中同一个向量的长度和夹角都不会发生变化.刚体变换也称为欧式变换. 视觉SLAM中使用的相机就是典型的刚体,相机 ...

  8. Unittest + python

    Unittest简单应用 #_*_coding:utf8_*_ import unittest from selenium import webdriver import time class Tes ...

  9. 12月centos单词

    ---恢复内容开始--- UNreachable:adj.(network server unreachable) 不能达到的; 及不到的; 取不到的; 不能得到的; rsync: rsync [re ...

  10. MyBatis基础入门《十八》动态SQL(if-where)

    MyBatis基础入门<十八>动态SQL(if-where) 描述: 代码是在<MyBatis基础入门<十七>动态SQL>基础上进行改造的,不再贴所有代码,仅贴改动 ...