1.数据类型

1.1基本类型

  • Number ——- 任意数值 ———— typeof
  • String ———- 任意字符串 ——— typeof
  • Boolean ——- true/false ———- typeof
  • undefined —- undefined ——— typeof/===

  • null ————— null ——————- ===

    1.2对象（引用）类型

  • Object —— 任意对象 ———- typeof/instanceof

  • Array ——- 特别对象（内部数据有序/数据下标） ———- instanceof
  • Function — 特别的对象（可以执行） —— typeof

    注意：typeof不能区别的类型:null与Object，Object和Array

1.3相关问题

  1. 1.undefined与null的区别?
  2.         undefined代表定义未赋值
  3.         nulll定义并赋值了, 只是值为null
  4. 2.什么时候给变量赋值为null呢?
  5.         初始赋值, 表明将要赋值为对象
  6.         结束前, 让对象成为垃圾对象(被垃圾回收器回收)
  7. 3. 严格区别变量类型与数据类型?
  8.     js的变量本身是没有类型的, 变量的类型实际上是变量内存中数据的类型
  9.     变量类型:
  10.       基本类型: 保存基本类型数据的变量
  11.       引用类型: 保存对象地址值的变量
  12.     数据对象
  13.       基本类型：保存就是基本类型的数据 
  14.       对象类型：保存的是地址值

2.数据，变量与内存

2.1什么是数据

  • 在内存中可读的, 可传递的保存了特定信息的’东东’
  • 一切皆数据, 函数也是数据
  • 在内存中的所有操作的目标: 数据

    包括（算术运算，逻辑运算、 赋值、运行函数）

2.2什么是变量?

  • 在程序运行过程中它的值是允许改变的量

  • 一个变量对应一块小内存, 它的值保存在此内存中

    2.3什么是内存?

  • 内存条通电后产生的存储空间(临时的)

  • 一块内存包含2个方面的数据
    • 内部存储的数据
    • 地址值数据

  • 内存空间的分类

    • 栈空间: 全局变量和局部变量
    • 堆空间: 对象

      2.4内存,数据, 变量三者之间的关系

  • 内存是容器, 用来存储不同数据

  • 变量是内存的标识, 通过变量我们可以操作(读/写)内存中的数据

    2.5相关问题

    2.5.1 关于赋值与内存的问题

    1. var a = xxx, a内存中到底保存的是什么?
    2. xxx是基本数据, 保存的就是这个数据
    3. xxx是对象, 保存的是对象的地址值
    4. xxx是一个变量, 保存的xxx的内存内容(可能是基本数据, 也可能是地址值)

    2.5.2关于引用变量赋值问题

    ```javascript 2个引用变量指向同一个对象, 通过一个变量修改对象内部数据, 另一个变量看到的是修改之后的数据 2个引用变量指向同一个对象, 让其中一个引用变量指向另一个对象, 另一引用变量依然指向前一个对象

var obj1 = {name: ‘Tom’} var obj2 = obj1 obj2.age = 12 console.log(obj1.age) // 12 function fn (obj) { obj.name = ‘A’ } fn(obj1) console.log(obj2.name) //A

var a = {age: 12} var b = a a = {name: ‘BOB’, age: 13} b.age = 14 console.log(b.age, a.name, a.age) // 14 Bob 13

function fn2 (obj) { obj = {age: 15} } fn2(a) console.log(a.age) //13

  1. <a name="afAgA"></a>
  2. ### 2.5.2关于数据传递问题
  3. ```javascript
  4. 在js调用函数时传递变量参数时, 是值传递还是引用传递
  5. 理解1: 都是值(基本/地址值)传递
  6. 理解2: 可能是值传递, 也可能是引用传递(地址值)
  9. var a = 3
  10.   function fn (a) {
  11.     a = a +1
  12.   }
  13.   fn(a)
  14.   console.log(a) //3
  16.   function fn2 (obj) {
  17.     console.log(obj.name)  //tom
  18.   }
  19.   var obj = {name: 'Tom'}
  20.   fn2(obj)

2.5.3JS引擎如何管理内存

  1. 1. 内存生命周期
  2.   * 分配小内存空间, 得到它的使用权
  3.   * 存储数据, 可以反复进行操作
  4.   * 释放小内存空间
  5. 2. 释放内存
  6.   * 局部变量: 函数执行完自动释放
  7.   * 对象: 成为垃圾对象==>垃圾回收器2回收
  9.  var a = 3
  10.   var obj = {}
  11.   obj = undefined
  12.   function fn () {
  13.     var b = {}
  14.   }
  15.   fn()  //b是自动释放, b所指向的对象是在后面的某个时刻由垃圾回收器回收

3.对象

  1. 什么是对象?
    多个数据的封装体
    用来保存多个数据的容器
    一个对象代表现实中的一个事物

  2. 为什么要用对象?

    统一管理多个数据

  3. 对象的组成

    属性: 属性名(字符串)和属性值(任意)组成
    方法: 一种特别的属性(属性值是函数)

  4. 如何访问对象内部数据?

    1.    属性名: 编码简单, 有时不能用<br />          ['属性名']: 编码麻烦, 能通用

    3.1问题: 什么时候必须使用[‘属性名’]的方式?

    1. 属性名包含特殊字符: - 空格
    2. 属性名不确定
    4. var p = {}
    5. //1. 给p对象添加一个属性: content type: text/json
    6. // p.content-type = 'text/json' //不能用
    7. p['content-type'] = 'text/json'
    8. console.log(p['content-type'])
    10. //2. 属性名不确定
    11. var propName = 'myAge'
    12. var value = 18
    13. // p.propName = value //不能用
    14. p[propName] = value
    15. console.log(p[propName])

4.函数

4.1什么是函数

实现特定功能的n条语句的封装体
只有函数是可以执行的, 其它类型的数据不能执行

4.2如何定义函数?

函数声明、表达式

4.3如何调用（执行）函数

  1. test()                  直接调用
  2. obj.test()          通过对象调用
  3. new test()          new调用
  4. test.call()/apply(obj)    通过临时让test成为obj的方法调用
  6. 定义函数
  7. function fn1 () {     //函数声明
  8.     console.log('fn1()')
  9.   }
  10.   var fn2 = function () { //表达式
  11.     console.log('fn2()')
  12.   }
  13.   fn1()
  14.   fn2()   //直接调用
  16. var obj = {}
  17.   function test2 () {
  18.     this.xxx = '你好'
  19.   }
  20.   // obj.test2()  不能直接, 根本就没有
  21.   test2.call(obj) //或者test2.apply(obj)   //可以让一个函数成为指定任意对象的方法进行调用
  22.   console.log(obj.xxx)  //输出你好

5.回调函数

5.1什么是回调函数

  1. 你定义的
  2. 你没有调
  3. 但是他最终执行了（在某个条件下或者某个时刻）

    5.2常见的回调函数

  • dom事件回调函数 ==>发生事件的dom元素
  • 定时器回调函数 ==>window
  • ajax请求回调函数

  • 生命周期回调函数

    1. // dom事件回调函数
    2. document.getElementById('btn').onclick = function () {
    3.   alert(this.innerHTML)
    4. }
    6. // 定时器回调函数
    7. setTimeout(function () {
    8.   alert('到点了'+this)
    9. }, 2000)

6.匿名函数自调用

  • 隐藏实现
  • 不会污染外部（全局）命名空间

  • 用它来编码js模块

    1. (function () { //匿名函数自调用
    2.   var a = 3
    3.   console.log(a + 3)
    4. })()
    6. var a = 4
    7. console.log(a)
    9. ;(function () {  //注意这里是小括号前面加了;
    10.   var a = 1
    11.   function test () {
    12.     console.log(++a)
    13.   }
    14.   window.$ = function () { // 向外暴露一个全局函数
    15.     return {
    16.       test: test
    17.     }
    18.   }
    19. })()
    21. $().test() // 1. $是一个函数 2. $执行后返回的是一个对象

7.函数中的this

7.1this是什么

  1. this是什么?
    任何函数本质上都是通过某个对象来调用的,如果没有直接指定就是window
     所有函数内部都有一个变量this
    它的值是调用函数的当前对象
    2. 如何确定this的值?
     test(): window
    p.test(): p
     new test(): 新创建的对象
    * p.call(obj): obj
  1.   function Person(color) {
  2.     console.log(this)
  3.     this.color = color;
  4.     this.getColor = function () {
  5.       console.log(this)
  6.       return this.color;
  7.     };
  8.     this.setColor = function (color) {
  9.       console.log(this)
  10.       this.color = color;
  11.     };
  12.   }
  14.   Person("red"); //this是谁? window
  16.   var p = new Person("yello"); //this是谁? p
  18.   p.getColor(); //this是谁? p
  20.   var obj = {};
  21.   p.setColor.call(obj, "black"); //this是谁? obj
  23.   var test = p.setColor;
  24.   test(); //this是谁? window
  26.   function fun1() {
  27.     function fun2() {
  28.       console.log(this);
  29.     }
  31.     fun2(); //this是谁? window
  32.   }
  33.   fun1();