js

数据类型：

1、基本类型：String、Number、boolean、undefined、null

2、对象类型：Object（任意对象）、Function（一种特殊的对象）、Array（一种特别的对象，内部数据是有序的）

 

判断方法：

1、typeof（返回数据类型的字符串表达）

　　可以判断：undefined、数值、字符串、boolean、function

　　不能判断：null和Object、Object和Array

2、instance：判断对象的具体类型

3、===    可以判断：undefined、null

var b1 = {
    b2: [1, 'abc', console.log],
    b3: function () {
      console.log('b3')
      return function () {
        return 'xfzhang'
      }
    }
  }

  console.log(b1 instanceof Object, b1 instanceof Array) // true  false
  console.log(b1.b2 instanceof Array, b1.b2 instanceof Object) // true true
  console.log(b1.b3 instanceof Function, b1.b3 instanceof Object) // true true

  console.log(typeof b1.b2, '-------') // 'object'

  console.log(typeof b1.b3==='function') // true

  console.log(typeof b1.b2[2]==='function')
  b1.b2[2](4)
  console.log(b1.b3()())

 

undefined和null的区别：undefinded代表定义未赋值，null定义并且赋值，其值为null

 

什么时候给变量赋值为null：

　　1、初始化的时候，表明该值之后将赋值为对象

　　2、结束前，让它成为垃圾对象（以便被垃圾回收器回收）

 

什么是数据：数据是存储在内存中的东西，本质上是0、1序列

数据的特点：可传递性，可运算，一切皆数据，内存中操作的目标：数据，算术运算、逻辑运算、赋值、运行函数

什么是内存：内存条通电后产生可以存储和数据的空间（临时空间），以小块内存的2个数据（地址值、内部存储的数据）

内存的分类：

　　栈：全局变量、局部变量　　

　　堆：对象

什么是变量：可以变化的量，由变量名和变量值构成，每个变量都对应一块小区域，变量名用于查找用户，变量值就是内存存储的数据

内存、变量、数据之间的关系：内存用来存放数据，变量用于表示数据

 

var = xxx

　　当xxx是基本数据类型的时候，保存的就是这个数据，xxx是对象的时候，保存的时候对象的地址值（xxx是一个变量，保存的xxx的内存内容，可能是基本数据、也可能是地址值）

 

引用变量赋值的：

　　多个引用变量指向同一个对象，通过一个变量修改对象内部的数据，另外的变量看到是修改之后的数据

<script type="text/javascript">
  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)
</script>

 

 

js引擎如何管理内存：

　　内存的声明周期：

　　　　分配好内存区域，得到使用权，存储数据，可以反复进行操作，释放内存

　　释放内存：

　　　　局部变量：函数执行完自动释放

　　　　对象：称为垃圾对象，垃圾回收期回收

 

 

什么是对象：多个数据的封装体，用来保存多个数据的容器，一个对象代表现实世界中的一个事务

为什么要使用对象：统一管理多个对象

对象的组成：

        属性：属性名（字符串）、属性值（任意类型）
　　方法：一种特别的属性（属性值是函数）

如何访问对象内部的数据：

　　1、对象.属性名

　　2、['属性值']

<script type="text/javascript">
  var p = {
    name: 'Tom',
    age: 12,
    setName: function (name) {
      this.name = name
    },
    setAge: function (age) {
      this.age = age
    }
  }

  p.setName('Bob')
  p['setAge'](23)
  console.log(p.name, p['age'])
</script>

什么时候必须使用['属性名']的方式：1、属性名包特殊字符的时候，2、属性名用变量的时候

<script type="text/javascript">
  var p = {}
  //1. 给p对象添加一个属性: content type: text/json
  // p.content-type = 'text/json' //不能用
  p['content-type'] = 'text/json'
  console.log(p['content-type'])

  //2. 属性名不确定
  var propName = 'myAge'
  var value = 18
  // p.propName = value //不能用
  p[propName] = value
  console.log(p[propName])
</script>

 

什么是函数：实现特定功能的多条语句的集合体，只有函数是可以执行的，其他类型的数据都是不可执行的

为什么要使用函数：提高代码的复用性，便于阅读交流

如何定义函数：1、函数声明　　2、表达式

var obj = {}
  function test2 () {
    this.xxx = 'atguigu'
  }
  // obj.test2()  不能直接, 根本就没有
  test2.call(obj) // obj.test2()   // 可以让一个函数成为指定任意对象的方法进行调用
  console.log(obj.xxx)

 

什么函数才是回调函数： 1、由自己定义的，2、自己没有进行调用，3、最终函数执行了

常见的回调函数：1、dom事件的回调函数， 2、定时器的回调函数， 3、ajax的异步回调函数， 4、声明周期的回调函数

 

IIFE：全称: Immediately-Invoked Function Expression

 作用：

　　隐藏实现，不污染全局命名空间，用它来编码js模块

(function () { //匿名函数自调用
    var a = 3
    console.log(a + 3)
  })()

(function () {
    var a = 1
    function test () {
      console.log(++a)
    }
    window.$ = function () { // 向外暴露一个全局函数
      return {
        test: test
      }
    }
  })()

  $().test() // 1. $是一个函数 2. $执行后返回的是一个对象

this是什么：

　　1、任何函数本质上都是通过某个对象来调用的，如果没有直接指定就是window

　　2、所有函数的内部都有一个变量this，它的值是调用函数的当前对象

Person("red"); //this是谁? window

  var p = new Person("yello"); //this是谁? p

  p.getColor(); //this是谁? p

  var obj = {};
  p.setColor.call(obj, "black"); //this是谁? obj

  var test = p.setColor;
  test(); //this是谁? window

函数的prototype属性：

　　每个函数都有一个prototype属性，它默认指向一个Object空对象（原型对象）

　　原型对象有一个属性constructor，它指向函数对象

给原型中添加属性（一般都是方法）：函数所有的实例对象中自动拥有原型对象中的属性

<script type="text/javascript">

  // 每个函数都有一个prototype属性, 它默认指向一个Object空对象(即称为: 原型对象)
  console.log(Date.prototype, typeof Date.prototype)
  function Fun () {

  }
  console.log(Fun.prototype)  // 默认指向一个Object空对象(没有我们的属性)

  // 原型对象中有一个属性constructor, 它指向函数对象
  console.log(Date.prototype.constructor===Date)
  console.log(Fun.prototype.constructor===Fun)

  //给原型对象添加属性(一般是方法) ===>实例对象可以访问
  Fun.prototype.test = function () {
    console.log('test()')
  }
  var fun = new Fun()
  fun.test()

</script>

每个函数function都有一个prototype，即显示原型（属性）

每个实例对象都有一个__proto__，可以成为隐式原型（属性）

对象的隐式原型值=构造函数的显示原型值

函数的prototype属性：在定义函数时候自动添加，默认是一个Object空对象

对象的__proto__属性：创建对象的时候自动添加，默认值是构造函数的prototype属性值

<script type="text/javascript">
  //定义构造函数
  function Fn() {   // 内部语句: this.prototype = {}

  }
  // 1. 每个函数function都有一个prototype，即显式原型属性, 默认指向一个空的Object对象
  console.log(Fn.prototype)
  // 2. 每个实例对象都有一个__proto__，可称为隐式原型
  //创建实例对象
  var fn = new Fn()  // 内部语句: this.__proto__ = Fn.prototype
  console.log(fn.__proto__)
  // 3. 对象的隐式原型的值为其对应构造函数的显式原型的值
  console.log(Fn.prototype===fn.__proto__) // true
  //给原型添加方法
  Fn.prototype.test = function () {
    console.log('test()')
  }
  //通过实例调用原型的方法
  fn.test()

</script>

　　

原型链：访问一个对象的属性时候：先在自身查找，找到返回，没有找到，则沿__proto__这条链向上查找，找到就返回，如果最终没有找到，返回undefined