# 10-24

参考：

现代 JavaScript 教程 (opens new window)

进度：🍅*10

JavaScript 基础知识 (opens new window)

代码质量 (opens new window)

对象 (opens new window)

对象拷贝，引用 (opens new window)

# 原子笔记

Number("") // 0
Number(null) // 0
Number(undefined) // NaN
Number(` \n \t \n `)  // 0
Boolean("0") // true
Boolean(" ") // true (任何非空字符串都是 true）

1
2
3
4
5
6

加号 + 被应用于字符串，它将合并（连接）各个字符串；只要任意一个运算元是字符串，那么另一个运算元也将被转化为字符串。
当对不同类型的值进行比较时，JavaScript 通常会首先将其转化为数字（number）再判定大小。
严格相等运算符 === 在进行比较时不会做任何的类型转换。

null == undefined // true
null == 0 // false
null >= 0 // true

1
2
3

相等性检查 == 和普通比较符 > < >= <= 的代码逻辑是相互独立的。undefined 和 null 在相等性检查 == 中不会进行任何的类型转换，除了彼此相等，不会等于任何其他值，在普通比较中则会进行类型转换。
一个或运算 || 的链，将返回第一个真值，如果没有真值就返回最后一个值；与运算&&返回第一个假值，如果没有假值就返回最后一个值。
非表达式的语法结构不能与三元运算符 ? 一起使用。
空值的return 或没有 return 的函数返回值为 undefined。
函数表达式是在代码执行到达时被创建，并且仅从那一刻起可用；在函数声明被定义之前，它就可以被调用。
使用for…in遍历一个对象，获取属性时：整数属性会被进行排序，其他属性则按照创建的顺序显示。
- “整数属性”指的是一个可以在不作任何更改的情况下转换为整数的字符串。
- 可以通过给每个键名加一个加号 "+" 前缀将整数属性转换为非整数属性。

# 笔记

# 递归深拷贝

function deepClone(obj) {
  // 原始类型直接返回
  if ( ! (obj && typeof obj === "object")) {
    return obj;
  }

  // 判断参数，创建拷贝对象
  let objClone = Array.isArray(obj) ? [] : {};

  // 递归
  for (key in obj) {
    objClone[key] =  deepClone(obj[key]);
  }

  return objClone;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 使用 Mocha 进行自动化测试

// test.js
// describe 描述功能
describe("pow", function () {
    
  // it 描述用例
  it("2 raised to power 3 is 8", function () {
    // 结果断言 具体测试代码
    assert.equal(pow(2, 3), 8);
  });
    
  // 最好将两个相互独立的检查拆分成两个更简单的检查
  it("3 raised to power 4 is 81", function () {
    assert.equal(pow(3, 4), 81);
  });
    
  // 使用嵌套的 describe 来进行分组
  describe("raises x to power 3", function () {
    // 使用 for 循环来生成用例
    for (let x = 1; x <= 5; x++) {
      makeTest(x);
    }

    function makeTest(x) {
      let expected = x * x * x;
      it(`${x} in the power 3 is ${expected}`, function () {
        assert.equal(pow(x, 3), expected);
      });
    }
  });

  //完成基础功能后，持续添加新规范，然后在代码中实现
  it("for negative n the result is NaN", function () {
    assert.isNaN(pow(2, -1));
  });

  it("for non-integer n the result is NaN", function () {
    assert.isNaN(pow(2, 1.5));
  });

  // 只运行此用例
  it.only("5 in the power of 2 equals 25", function () {
    assert.equal(pow(5, 2), 25);
  });

  // before/after 函数来在运行测试之前/之后执行
  before(() => alert("Testing started – before all tests"));
  after(() => alert("Testing finished – after all tests"));

  // beforeEach/afterEach 函数在执行每一个 it 之前/之后执行
  beforeEach(() => console.log("Before a test – enter a test"));
  afterEach(() => console.log("After a test – exit a test"));

});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# 示例 HTML

引入 Mocha (opens new window)（核心测试框架）、Chai (opens new window)（断言支持）以及测试函数、测试代码。

<!DOCTYPE html>
<html>
<head>
  <!-- 用于测试的第三方库和样式文件 -->
    
  <!-- add mocha css, to show results -->
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
  <!-- add mocha framework code -->
  <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
  <script>
    mocha.setup('bdd'); // minimal setup
  </script>
  <!-- add chai -->
  <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
  <script>
    // chai has a lot of stuff, let's make assert global
    let assert = chai.assert;
  </script>
</head>

<body>
  <!-- 测试函数 -->	
  <script>
    function pow(x, n) {
      /* function code is to be written, empty now */
    }
  </script>

  <!-- 测试代码 the script with tests (describe, it...) -->
  <script src="test.js"></script>

  <!-- the element with id="mocha" will contain test results -->
  <div id="mocha"></div>

  <!-- run tests! -->
  <script>
    mocha.run();
  </script>
</body>

</html>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

← 10-27 10-23 →