函数（下）

作用域

  • 什么是作用域，就是一个变量可以生效的范围
  • 变量不是在所有地方都可以使用的，而这个变量的使用范围就是作用域

全局作用域

  • 全局作用域是最大的作用域
  • 在全局作用域中定义的变量可以在任何地方使用
  • 页面打开的时候，浏览器会自动给我们生成一个全局作用域 window
  • 这个作用域会一直存在，直到页面关闭就销毁了
    1. // 下面两个变量都是存在在全局作用域下面的，都是可以在任意地方使用的
    2. var num = 100
    3. var num2 = 200

局部作用域

  • 局部作用域就是在全局作用域下面有开辟出来的一个相对小一些的作用域
  • 在局部作用域中定义的变量只能在这个局部作用域内部使用
  • 在 JS 中只有函数能生成一个局部作用域，别的都不行
  • 每一个函数，都是一个局部作用域 ```javascript // 这个 num 是一个全局作用域下的变量 在任何地方都可以使用 var num = 100

function fn() { // 下面这个变量就是一个 fn 局部作用域内部的变量 // 只能在 fn 函数内部使用 var num2 = 200 }

fn()

  2. <a name="1fa48b57"></a>
  3. ## 变量使用规则
  5. - 有了作用域以后，变量就有了使用范围，也就有了使用规则
  6. - 变量使用规则分为两种，**访问规则** 和 **赋值规则**
  8. <a name="d9f3f815"></a>
  9. ### 访问规则
  11. - 当我想获取一个变量的值的时候，我们管这个行为叫做 **访问**
  12. - 获取变量的规则：
  13.    - 首先，在自己的作用域内部查找，如果有，就直接拿来使用
  14.    - 如果没有，就去上一级作用域查找，如果有，就拿来使用
  15.    - 如果没有，就继续去上一级作用域查找，依次类推
  16.    - 如果一直到全局作用域都没有这个变量，那么就会直接报错（该变量 is not defined）
  17. ```javascript
  18. var num = 100
  20. function fn() {
  21.   var num2 = 200
  23.   function fun() {
  24.     var num3 = 300
  26.     console.log(num3) // 自己作用域内有，拿过来用
  27.     console.log(num2) // 自己作用域内没有，就去上一级，就是 fn 的作用域里面找，发现有，拿过来用
  28.     console.log(num) // 自己这没有，去上一级 fn 那里也没有，再上一级到全局作用域，发现有，直接用
  29.     console.log(a) // 自己没有，一级一级找上去到全局都没有，就会报错
  30.   }
  32.   fun()
  33. }
  35. fn()
  • 变量的访问规则 也叫做 作用域的查找机制
  • 作用域的查找机制只能是向上找，不能向下找 ```javascript function fn() { var num = 100 } fn()

console.log(num) // 发现自己作用域没有，自己就是全局作用域，没有再上一级了，直接报错

  2. <a name="2f78888d"></a>
  3. ### 赋值规则
  5. - 当你想给一个变量赋值的时候，那么就先要找到这个变量，在给他赋值
  6. - 变量赋值规则：
  7.    - 先在自己作用域内部查找，有就直接赋值
  8.    - 没有就去上一级作用域内部查找，有就直接赋值
  9.    - 在没有再去上一级作用域查找，有就直接赋值
  10.    - 如果一直找到全局作用域都没有，那么就把这个变量定义为全局变量，在给他赋值
  11. ```javascript
  12. function fn() {
  13.   num = 100
  14. }
  15. fn()
  17. // fn 调用以后，要给 num 赋值
  18. // 查看自己的作用域内部没有 num 变量
  19. // 就会向上一级查找
  20. // 上一级就是全局作用域，发现依旧没有
  21. // 那么就会把 num 定义为全局的变量，并为其赋值
  22. // 所以 fn() 以后，全局就有了一个变量叫做 num 并且值是 100
  23. console.log(num) // 100

递归函数

  • 什么是递归函数
  • 在编程世界里面，递归就是一个自己调用自己的手段

  • 递归函数： 一个函数内部，调用了自己，循环往复

    1. // 下面这个代码就是一个最简单的递归函数
    2. // 在函数内部调用了自己，函数一执行，就调用自己一次，在调用再执行，循环往复，没有止尽
    3. function fn() {
    4. fn()
    5. }
    6. fn()

  • 其实递归函数和循环很类似

  • 需要有初始化，自增，执行代码，条件判断的，不然就是一个没有尽头的递归函数，我们叫做 死递归

简单实现一个递归

  • 我们先在用递归函数简单实现一个效果
  • 需求： 求 1 至 5 的和
    • 先算 1 + 2 得 3
    • 再算 3 + 3 得 6
    • 再算 6 + 4 得 10
    • 再算 10 + 5 得 15
    • 结束
  • 开始书写，写递归函数先要写结束条件（为了避免出现 “死递归”） ```javascript function add(n) { // 传递进来的是 1 // 当 n === 5 的时候要结束 if (n === 5) { return 5 } }

add(1)

  2. - 再写不满足条件的时候我们的递归处理
  3. ```javascript
  4. function add(n) {
  5.   // 传递进来的是 1
  6.   // 当 n === 5 的时候要结束
  7.   if (n === 5) {
  8.     return 5
  9.   } else {
  10.     // 不满足条件的时候，就是当前数字 + 比自己大 1 的数字
  11.     return n + add(n + 1)
  12.   }
  13. }
  14. add(1)

简单了解对象

  • 对象是一个复杂数据类型

  • 其实说是复杂，但是没有很复杂，只不过是存储了一些基本数据类型的一个集合

    1. var obj = {
    2. num: 100,
    3. str: 'hello world',
    4. boo: true
    5. }

  • 这里的 {} 和函数中的 {} 不一样

  • 函数里面的是写代码的，而对象里面是写一些数据的
  • 对象就是一个键值对的集合
  • {} 里面的每一个键都是一个成员
  • 也就是说，我们可以把一些数据放在一个对象里面，那么他们就互不干扰了
  • 其实就是我们准备一个房子，把我们想要的数据放进去，然后把房子的地址给到变量名，当我们需要某一个数据的时候，就可以根据变量名里面存储的地址找到对应的房子，然后去房子里面找到对应的数据

创建一个对象

  • 字面量的方式创建一个对象 ```javascript // 创建一个空对象 var obj = {}

// 像对象中添加成员 obj.name = ‘Jack’ obj.age = 18

  2. - 内置构造函数的方式创建对象
  3. ```javascript
  4. // 创建一个空对象
  5. var obj = new Object()
  7. // 向对象中添加成员
  8. obj.name = 'Rose'
  9. obj.age = 20
  • Object 是 js 内置给我们的构造函数，用于创建一个对象使用的