数据类型：
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